@finos/legend-graph 0.1.2 → 0.1.3

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ExecutionPlanBuilder.ts

@@ -133,7 +133,7 @@ const buildTDSColumn = (
   const metamodel = new TDSColumn();
   metamodel.name = guaranteeNonNullable(
     protocol.name,
-    'TDS column name is missing',
+    `TDS column 'name' field is missing`,
   );
   metamodel.documentation = protocol.doc;
   metamodel.sourceDataType = protocol.relationalType
@@ -182,7 +182,7 @@ const buildSQLResultColumn = (
   const metamodel = new SQLResultColumn();
   metamodel.label = guaranteeNonNullable(
     protocol.label,
-    'SQL result column label is missing',
+    `SQL result column 'label' field is missing`,
   );
   metamodel.dataType = protocol.dataType
     ? parseDataType(protocol.dataType)
@@ -215,7 +215,7 @@ const buildSQLExecutionNode = (
   buildBaseExecutionNode(metamodel, protocol, context);
   metamodel.sqlQuery = guaranteeNonNullable(
     protocol.sqlQuery,
-    'SQL execution node SQL query is missing',
+    `SQL execution node 'sqlQuery' field is missing`,
   );
   metamodel.onConnectionCloseCommitQuery =
     protocol.onConnectionCloseCommitQuery;
@@ -226,7 +226,7 @@ const buildSQLExecutionNode = (
       new V1_ProtocolToMetaModelConnectionBuilder(context),
     ),
     DatabaseConnection,
-    'SQL execution node connection must be of type database connection',
+    'SQL execution node connection must be a database connection',
   );
   metamodel.resultColumns = protocol.resultColumns.map(buildSQLResultColumn);
   return metamodel;
@@ -263,7 +263,7 @@ export const V1_buildExecutionPlan = (
     const metamodel = new ExecutionPlan();
     metamodel.authDependent = guaranteeNonNullable(
       protocol.authDependent,
-      'Single execution plan authentication dependent flag is missing',
+      `Single execution plan 'authDependent' field is missing`,
     );
     metamodel.kerberos = protocol.kerberos;
     metamodel.processingTemplateFunctions = protocol.templateFunctions;

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_GraphBuilderContext.ts

@@ -205,11 +205,11 @@ export class V1_GraphBuilderContext {
   ): StereotypeImplicitReference => {
     assertNonEmptyString(
       stereotypePtr.profile,
-      'Steoreotype pointer profile is missing',
+      `Steoreotype pointer 'profile' field is missing or empty`,
     );
     assertNonEmptyString(
       stereotypePtr.value,
-      'Steoreotype pointer value is missing',
+      `Steoreotype pointer 'value' field is missing or empty`,
     );
     const ownerReference = this.resolveProfile(stereotypePtr.profile);
     const value = ownerReference.value.getStereotype(stereotypePtr.value);
@@ -217,8 +217,14 @@ export class V1_GraphBuilderContext {
   };
 
   resolveTag = (tagPtr: V1_TagPtr): TagImplicitReference => {
-    assertNonEmptyString(tagPtr.profile, 'Tag pointer profile is missing');
-    assertNonEmptyString(tagPtr.value, 'Tag pointer value is missing');
+    assertNonEmptyString(
+      tagPtr.profile,
+      `Tag pointer 'profile' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      tagPtr.value,
+      `Tag pointer 'value' field is missing or empty`,
+    );
     const ownerReference = this.resolveProfile(tagPtr.profile);
     const value = ownerReference.value.getTag(tagPtr.value);
     return TagImplicitReference.create(ownerReference, value);
@@ -235,11 +241,11 @@ export class V1_GraphBuilderContext {
   ): PropertyImplicitReference => {
     assertNonEmptyString(
       propertyPtr.class,
-      'Property pointer class is missing',
+      `Property pointer 'class' field is missing or empty`,
     );
     assertNonEmptyString(
       propertyPtr.property,
-      'Property pointer name is missing',
+      `Property pointer 'property' field is missing or empty`,
     );
     const ownerReference = this.resolveClass(propertyPtr.class);
     const value = ownerReference.value.getOwnedProperty(propertyPtr.property);
@@ -251,11 +257,11 @@ export class V1_GraphBuilderContext {
   ): PropertyImplicitReference => {
     assertNonEmptyString(
       propertyPtr.class,
-      'Property pointer class is missing',
+      `Property pointer 'class' field is missing or empty`,
     );
     assertNonEmptyString(
       propertyPtr.property,
-      'Property pointer name is missing',
+      `Property pointer 'property' field is missing or empty`,
     );
     const ownerReference = this.resolveClass(propertyPtr.class);
     const value = ownerReference.value.getProperty(propertyPtr.property);
@@ -267,11 +273,11 @@ export class V1_GraphBuilderContext {
   ): RootFlatDataRecordTypeImplicitReference => {
     assertNonEmptyString(
       classMapping.flatData,
-      'Flat-data class mapping source flat-data store is missing',
+      `Flat-data class mapping 'flatData' field is missing or empty`,
     );
     assertNonEmptyString(
       classMapping.sectionName,
-      'Flat-data class mapping source flat-data section is missing',
+      `Flat-data class mapping 'sectionName' field is missing or empty`,
     );
     const ownerReference = this.resolveFlatDataStore(classMapping.flatData);
     const value = ownerReference.value
@@ -288,10 +294,16 @@ export class V1_GraphBuilderContext {
   ): ViewImplicitReference | TableImplicitReference => {
     assertNonEmptyString(
       tablePtr.database,
-      'Table pointer database is missing',
+      `Table pointer 'database' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      tablePtr.schema,
+      `Table pointer 'schema' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      tablePtr.table,
+      `Table pointer 'table' field is missing or empty`,
     );
-    assertNonEmptyString(tablePtr.schema, 'Table pointer schema is missing');
-    assertNonEmptyString(tablePtr.table, 'Table pointer table is missing');
     const ownerReference = this.resolveDatabase(tablePtr.database);
     const value = V1_getRelation(
       ownerReference.value,
@@ -302,16 +314,28 @@ export class V1_GraphBuilderContext {
   };
 
   resolveJoin = (joinPtr: V1_JoinPointer): JoinImplicitReference => {
-    assertNonEmptyString(joinPtr.db, 'Join pointer database is missing');
-    assertNonEmptyString(joinPtr.name, 'Join pointer name is missing');
+    assertNonEmptyString(
+      joinPtr.db,
+      `Join pointer 'db' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      joinPtr.name,
+      `Join pointer 'name' field is missing or empty`,
+    );
     const ownerReference = this.resolveDatabase(joinPtr.db);
     const value = ownerReference.value.getJoin(joinPtr.name);
     return JoinImplicitReference.create(ownerReference, value);
   };
 
   resolveFilter = (filterPtr: V1_FilterPointer): FilterImplicitReference => {
-    assertNonEmptyString(filterPtr.db, 'Filter pointer database is missing');
-    assertNonEmptyString(filterPtr.name, 'Filter pointer name is missing');
+    assertNonEmptyString(
+      filterPtr.db,
+      `Filter pointer 'db' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      filterPtr.name,
+      `Filter pointer 'name' field is missing or empty`,
+    );
     const ownerReference = this.resolveDatabase(filterPtr.db);
     const value = ownerReference.value.getFilter(filterPtr.name);
     return FilterImplicitReference.create(ownerReference, value);

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelClassMappingFirstPassBuilder.ts

@@ -61,15 +61,15 @@ export class V1_ProtocolToMetaModelClassMappingFirstPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Operation class mapping class is missing',
+      `Operation class mapping 'class' field is missing or empty`,
     );
     assertNonNullable(
       classMapping.root,
-      'Operation class mapping root flag is missing',
+      `Operation class mapping 'root' field is missing`,
     );
     assertNonNullable(
       classMapping.operation,
-      'Operation class mapping operation is missing',
+      `Operation class mapping operation is missing`,
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     return new OperationSetImplementation(
@@ -86,11 +86,11 @@ export class V1_ProtocolToMetaModelClassMappingFirstPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Model-to-model class mapping class is missing',
+      `Pure instance class mapping 'class' field is missing or empty`,
     );
     assertNonNullable(
       classMapping.root,
-      'Model-to-model class mapping root flag is missing',
+      `Pure instance class mapping 'root' field is missing`,
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     const srcClassReference = classMapping.srcClass
@@ -114,11 +114,11 @@ export class V1_ProtocolToMetaModelClassMappingFirstPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Flat-data class mapping class is missing',
+      `Flat-data class mapping 'class' field is missing or empty`,
     );
     assertNonNullable(
       classMapping.root,
-      'Flat-data class mapping root flag is missing',
+      `Flat-data class mapping 'root' field is missing`,
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     const sourceRootRecordType =
@@ -148,11 +148,11 @@ export class V1_ProtocolToMetaModelClassMappingFirstPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Relational class mapping class is missing',
+      `Relational class mapping 'class' field is missing or empty`,
     );
     assertNonNullable(
       classMapping.root,
-      'Relational class mapping root flag is missing',
+      `Relational class mapping 'root' field is missing`,
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     const rootRelationalInstanceSetImplementation =
@@ -173,11 +173,11 @@ export class V1_ProtocolToMetaModelClassMappingFirstPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Aggregation-aware class mapping class is missing',
+      `Aggregation-aware class mapping 'class' field is missing or empty`,
     );
     assertNonNullable(
       classMapping.root,
-      'Aggregation-aware class mapping root flag is missing',
+      `Aggregation-aware class mapping 'root' field is missing`,
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     const mapping = this.context.graph.getMapping(this.parent.path);

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelClassMappingSecondPassBuilder.ts

@@ -76,7 +76,7 @@ export class V1_ProtocolToMetaModelClassMappingSecondPassBuilder
   visit_OperationClassMapping(classMapping: V1_OperationClassMapping): void {
     assertNonEmptyString(
       classMapping.class,
-      'Operation class mapping class is missing',
+      `Operation class mapping 'class' field is missing or empty`,
     );
     const id = V1_getInferredClassMappingId(
       this.context.resolveClass(classMapping.class).value,
@@ -116,7 +116,7 @@ export class V1_ProtocolToMetaModelClassMappingSecondPassBuilder
   ): void {
     assertNonEmptyString(
       classMapping.class,
-      'Model-to-model class mapping class is missing',
+      `Pure instance class mapping 'class' field is missing or empty`,
     );
     const pureInstanceSetImplementation = guaranteeType(
       getOwnClassMappingById(
@@ -149,7 +149,7 @@ export class V1_ProtocolToMetaModelClassMappingSecondPassBuilder
   ): void {
     assertNonEmptyString(
       classMapping.class,
-      'Flat-data class mapping class is missing',
+      `Flat-data class mapping 'class' field is missing or empty`,
     );
     const flatDataInstanceSetImplementation = guaranteeType(
       getOwnClassMappingById(
@@ -183,7 +183,7 @@ export class V1_ProtocolToMetaModelClassMappingSecondPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Relational class mapping class is missing',
+      `Relational class mapping 'class' field is missing or empty`,
     );
     const rootRelationalInstanceSetImplementation = guaranteeType(
       getOwnClassMappingById(
@@ -272,7 +272,7 @@ export class V1_ProtocolToMetaModelClassMappingSecondPassBuilder
   ): SetImplementation {
     assertNonEmptyString(
       classMapping.class,
-      'Aggregation-aware class mapping class is missing',
+      `Aggregation-aware class mapping 'class' field is missing or empty`,
     );
     const aggragetionAwareInstanceSetImplementation = guaranteeType(
       getOwnClassMappingById(

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelConnectionBuilder.ts

@@ -91,7 +91,7 @@ export class V1_ProtocolToMetaModelConnectionBuilder
   visit_ConnectionPointer(connection: V1_ConnectionPointer): Connection {
     assertNonNullable(
       connection.connection,
-      'Connection pointer connection is missing',
+      `Connection pointer 'connection' field is missing`,
     );
     return new ConnectionPointer(
       this.context.resolveConnection(connection.connection),
@@ -140,9 +140,12 @@ export class V1_ProtocolToMetaModelConnectionBuilder
     }
     assertNonNullable(
       connection.class,
-      'JSON model connection class is missing',
+      `JSON model connection 'class' field is missing`,
+    );
+    assertNonNullable(
+      connection.url,
+      `JSON model connection 'url' field is missing`,
     );
-    assertNonNullable(connection.url, 'JSON model connection data is missing');
     return new JsonModelConnection(
       PackageableElementImplicitReference.create(
         this.context.graph.modelStore,
@@ -168,9 +171,12 @@ export class V1_ProtocolToMetaModelConnectionBuilder
     }
     assertNonNullable(
       connection.class,
-      'XML model connection class is missing',
+      `XML model connection 'class' field is missing`,
+    );
+    assertNonNullable(
+      connection.url,
+      `XML model connection 'url' field is missing`,
     );
-    assertNonNullable(connection.url, 'XML model connection data is missing');
     return new XmlModelConnection(
       PackageableElementImplicitReference.create(
         this.context.graph.modelStore,
@@ -186,7 +192,7 @@ export class V1_ProtocolToMetaModelConnectionBuilder
       ? this.context.resolveFlatDataStore(
           guaranteeNonNullable(
             connection.store,
-            'Flat-data connection store is missing',
+            `Flat-data connection 'store' field is missing`,
           ),
         )
       : connection.store
@@ -195,12 +201,15 @@ export class V1_ProtocolToMetaModelConnectionBuilder
           assertType(
             this.embeddedConnectionStore.value,
             FlatData,
-            'Flat-data connection store must be a flat-data store',
+            `Flat-data connection store must be a flat-data store`,
           );
           return this
             .embeddedConnectionStore as PackageableElementReference<FlatData>;
         })();
-    assertNonNullable(connection.url, 'Flat-data connection data is missing');
+    assertNonNullable(
+      connection.url,
+      `Flat-data connection 'url' field is missing`,
+    );
     return new FlatDataConnection(store, connection.url);
   }
 
@@ -211,7 +220,7 @@ export class V1_ProtocolToMetaModelConnectionBuilder
       ? this.context.resolveDatabase(
           guaranteeNonNullable(
             connection.store,
-            'Relational database connection store is missing',
+            `Relational database connection 'store' field is missing`,
           ),
         )
       : connection.store
@@ -220,22 +229,22 @@ export class V1_ProtocolToMetaModelConnectionBuilder
           assertType(
             this.embeddedConnectionStore.value,
             Database,
-            'Relational database connection store must be a database',
+            `Relational database connection store must be a database`,
           );
           return this
             .embeddedConnectionStore as PackageableElementReference<Database>;
         })();
     assertNonNullable(
       connection.type,
-      'Relational database connection type is missing',
+      `Relational database connection 'type' field is missing`,
     );
     assertNonNullable(
       connection.datasourceSpecification,
-      'Relational database connection datasource specification is missing',
+      `Relational database connection 'datasourceSpecification' field is missing`,
     );
     assertNonNullable(
       connection.authenticationStrategy,
-      'Relational database connection authentication strategy is missing',
+      `Relational database connection 'authenticationStrategy' field is missing`,
     );
     const val = new RelationalDatabaseConnection(
       store,

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFirstPassBuilder.ts

@@ -75,8 +75,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_SectionIndex(element: V1_SectionIndex): PackageableElement {
-    assertNonEmptyString(element.package, 'Section index package is missing');
-    assertNonEmptyString(element.name, 'Section index is missing');
+    assertNonEmptyString(
+      element.package,
+      `Section index 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Section index 'name' field is missing or empty`,
+    );
     const sectionIndex = new SectionIndex(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -91,8 +97,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Profile(element: V1_Profile): PackageableElement {
-    assertNonEmptyString(element.package, 'Profile package is missing');
-    assertNonEmptyString(element.name, 'Profile name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Profile 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Profile 'name' field is missing or empty`,
+    );
     const profile = new Profile(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -110,8 +122,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Enumeration(element: V1_Enumeration): PackageableElement {
-    assertNonEmptyString(element.package, 'Enumeration package is missing');
-    assertNonEmptyString(element.name, 'Enumeration name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Enumeration 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Enumeration 'name' field is missing or empty`,
+    );
     const pureEnumeration = new Enumeration(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -129,8 +147,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Measure(element: V1_Measure): PackageableElement {
-    assertNonEmptyString(element.package, 'Measure package is missing');
-    assertNonEmptyString(element.name, 'Measure name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Measure 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Measure 'name' field is missing or empty`,
+    );
     const pureMeasure = new Measure(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -148,8 +172,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Class(element: V1_Class): PackageableElement {
-    assertNonEmptyString(element.package, 'Class package is missing');
-    assertNonEmptyString(element.name, 'Class name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Class 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Class 'name' field is missing or empty`,
+    );
     const _class = new Class(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -167,8 +197,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Association(element: V1_Association): PackageableElement {
-    assertNonEmptyString(element.package, 'Association package is missing');
-    assertNonEmptyString(element.name, 'Association name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Association 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Association 'name' field is missing or empty`,
+    );
     const association = new Association(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -188,8 +224,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   visit_ConcreteFunctionDefinition(
     element: V1_ConcreteFunctionDefinition,
   ): PackageableElement {
-    assertNonEmptyString(element.package, 'Function package is missing');
-    assertNonEmptyString(element.name, 'Function name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Function 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Function 'name' field is missing or empty`,
+    );
     const func = new ConcreteFunctionDefinition(
       element.name,
       // This is just a stub to fill in when we first create the function
@@ -217,8 +259,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_FlatData(element: V1_FlatData): PackageableElement {
-    assertNonEmptyString(element.package, 'Flat-data store package is missing');
-    assertNonEmptyString(element.name, 'Flat data store name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Flat-data store 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Flat data store 'name' field is missing or empty`,
+    );
     const flatData = new FlatData(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -236,8 +284,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Database(element: V1_Database): PackageableElement {
-    assertNonEmptyString(element.package, 'Database store package is missing');
-    assertNonEmptyString(element.name, 'Database store name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Database store 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Database store 'name' field is missing or empty`,
+    );
     const database = new Database(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -255,8 +309,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_ServiceStore(element: V1_ServiceStore): PackageableElement {
-    assertNonEmptyString(element.package, 'Service store package is missing');
-    assertNonEmptyString(element.name, 'Service store name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Service store 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Service store 'name' field is missing or empty`,
+    );
     const serviceStore = new ServiceStore(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -274,8 +334,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Mapping(element: V1_Mapping): PackageableElement {
-    assertNonEmptyString(element.package, 'Mapping package is missing');
-    assertNonEmptyString(element.name, 'Mapping name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Mapping 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Mapping 'name' field is missing or empty`,
+    );
     const pureMapping = new Mapping(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -293,8 +359,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_Service(element: V1_Service): PackageableElement {
-    assertNonEmptyString(element.package, 'Service package is missing');
-    assertNonEmptyString(element.name, 'Service name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Service 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Service 'name' field is missing or empty`,
+    );
     const service = new Service(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -370,8 +442,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   }
 
   visit_PackageableRuntime(element: V1_PackageableRuntime): PackageableElement {
-    assertNonEmptyString(element.package, 'Runtime package is missing');
-    assertNonEmptyString(element.name, 'Runtime name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Runtime 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Runtime 'name' field is missing or empty`,
+    );
     const runtime = new PackageableRuntime(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,
@@ -391,8 +469,14 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   visit_PackageableConnection(
     element: V1_PackageableConnection,
   ): PackageableElement {
-    assertNonEmptyString(element.package, 'Connection package is missing');
-    assertNonEmptyString(element.name, 'Connection name is missing');
+    assertNonEmptyString(
+      element.package,
+      `Connection 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Connection 'name' field is missing or empty`,
+    );
     const connection = new PackageableConnection(element.name);
     const path = this.context.currentSubGraph.buildPath(
       element.package,