@finos/legend-graph 0.1.2 → 0.1.3

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

@@ -68,15 +68,15 @@ export const V1_buildDatasourceSpecification = (
   if (protocol instanceof V1_StaticDatasourceSpecification) {
     assertNonEmptyString(
       protocol.host,
-      'Static datasource specification host is missing',
+      `Static datasource specification 'host' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.databaseName,
-      'Static datasource specification database is missing',
+      `Static datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonNullable(
       protocol.port,
-      'Static datasource specification port is missing',
+      `Static datasource specification 'port' field is missing`,
     );
     const staticSpec = new StaticDatasourceSpecification(
       protocol.host,
@@ -87,15 +87,15 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_EmbeddedH2DatasourceSpecification) {
     assertNonEmptyString(
       protocol.databaseName,
-      'Embedded H2 datasource specification databaseName is missing',
+      `Embedded H2 datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.directory,
-      'Embedded H2 datasource specification directory is missing',
+      `Embedded H2 datasource specification 'directory' field is missing or empty`,
     );
     assertNonNullable(
       protocol.autoServerMode,
-      'Embedded H2 datasource specification autoServerMode is missing',
+      `Embedded H2 datasource specification 'autoServerMode' field is missing or empty`,
     );
     const embeddedSpec = new EmbeddedH2DatasourceSpecification(
       protocol.databaseName,
@@ -106,19 +106,19 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_SnowflakeDatasourceSpecification) {
     assertNonEmptyString(
       protocol.accountName,
-      'Snowflake datasource specification property is missing',
+      `Snowflake datasource specification 'accountName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.region,
-      'Snowflake datasource specification region is missing',
+      `Snowflake datasource specification 'region' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.warehouseName,
-      'Snowflake datasource specification warehouseName is missing',
+      `Snowflake datasource specification 'warehouseName' field is missing or empty`,
     );
     assertNonNullable(
       protocol.databaseName,
-      'Snowflake datasource specification databaseName is missing',
+      `Snowflake datasource specification 'databaseName' field is missing`,
     );
     const snowflakeSpec = new SnowflakeDatasourceSpecification(
       protocol.accountName,
@@ -129,11 +129,16 @@ export const V1_buildDatasourceSpecification = (
     snowflakeSpec.cloudType = protocol.cloudType;
     snowflakeSpec.quotedIdentifiersIgnoreCase =
       protocol.quotedIdentifiersIgnoreCase;
+    snowflakeSpec.proxyHost = protocol.proxyHost;
+    snowflakeSpec.proxyPort = protocol.proxyPort;
+    snowflakeSpec.nonProxyHosts = protocol.nonProxyHosts;
+    snowflakeSpec.organization = protocol.organization;
+    snowflakeSpec.accountType = protocol.accountType;
     return snowflakeSpec;
   } else if (protocol instanceof V1_BigQueryDatasourceSpecification) {
     assertNonEmptyString(
       protocol.projectId,
-      'BigQuery datasource specification property project ID is missing',
+      `BigQuery datasource specification 'projectId' field is missing or empty`,
     );
     const bigQuerySpec = new BigQueryDatasourceSpecification(
       protocol.projectId,
@@ -148,15 +153,15 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_RedshiftDatasourceSpecification) {
     assertNonEmptyString(
       protocol.databaseName,
-      'Redshift datasource specification databaseName is missing',
+      `Redshift datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.endpoint,
-      'Redshift datasource specification endpoint is missing',
+      `Redshift datasource specification 'endpoint' field is missing or empty`,
     );
     assertNonNullable(
       protocol.port,
-      'Redshift datasource specification port is missing',
+      `Redshift datasource specification 'port' field is missing or empty`,
     );
     const redshiftSpec = new RedshiftDatasourceSpecification(
       protocol.databaseName,
@@ -197,15 +202,15 @@ export const V1_buildAuthenticationStrategy = (
   } else if (protocol instanceof V1_SnowflakePublicAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.privateKeyVaultReference,
-      'Snowflake public authentication strategy private key vault reference is missing or empty',
+      `Snowflake public authentication strategy 'privateKeyVaultReference' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.passPhraseVaultReference,
-      'Snowflake public authentication strategy pass phrase vault reference is missing or empty',
+      `Snowflake public authentication strategy 'passPhraseVaultReference' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.publicUserName,
-      'Snowflake public authentication user name is missing or empty',
+      `Snowflake public authentication 'publicUserName' field is missing or empty`,
     );
     return new SnowflakePublicAuthenticationStrategy(
       protocol.privateKeyVaultReference,
@@ -233,11 +238,11 @@ export const V1_buildAuthenticationStrategy = (
   } else if (protocol instanceof V1_UserPasswordAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.userName,
-      'User password authentication strategy userName is missing or empty',
+      `User password authentication strategy 'userName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.passwordVaultReference,
-      'User password authentication strategy passwordVaultReference is missing or empty',
+      `User password authentication strategy 'passwordVaultReference' field is missing or empty`,
     );
     return new UserPasswordAuthenticationStrategy(
       protocol.userName,

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

@@ -42,12 +42,12 @@ export const V1_buildEngineRuntime = (
       protocolStoreConnections.storeConnections.map((identifiedConnection) => {
         assertNonEmptyString(
           identifiedConnection.id,
-          'Runtime connection ID is missing',
+          `Runtime connection 'id' field is missing`,
         );
         // make sure runtime connection IDs are unique
         assertTrue(
           !connectionIds.has(identifiedConnection.id),
-          'Runtime connection ID must be unique',
+          `Runtime connection ID must be unique`,
         );
         connectionIds.add(identifiedConnection.id);
         const connection =
@@ -57,7 +57,7 @@ export const V1_buildEngineRuntime = (
         // make sure connection are indexed by store properly
         assertTrue(
           connection.store.value === store.value,
-          'Runtime connections must be correctly indexed by store',
+          `Runtime connections must be correctly indexed by store`,
         );
         return new IdentifiedConnection(identifiedConnection.id, connection);
       });

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

@@ -74,7 +74,7 @@ export const V1_buildServiceTest = (
     assertType(
       parentService.execution,
       PureSingleExecution,
-      'Service with single execution requires a single execution test',
+      'Service with single-execution requires a single-execution test',
     );
     const singleTest = new SingleExecutionTest(parentService, serviceTest.data);
     singleTest.asserts = serviceTest.asserts.map((assert) => {
@@ -94,12 +94,12 @@ export const V1_buildServiceTest = (
     assertType(
       parentService.execution,
       PureMultiExecution,
-      'Service with multi execution requires a multi execution test',
+      'Service with multi-execution requires a multi-execution test',
     );
     const multiTest = new MultiExecutionTest(parentService);
     if (!serviceTest.tests.length) {
       throw new GraphBuilderError(
-        'Service multi execution test must not be empty',
+        'Service multi-execution test must not be empty',
       );
     }
     const executionKeys = new Set(
@@ -111,12 +111,12 @@ export const V1_buildServiceTest = (
     multiTest.tests = serviceTest.tests.map((test) => {
       assertNonEmptyString(
         test.key,
-        'Service multi execution test key is missing',
+        'Service multi-execution test key is missing',
       );
       // check duplicated key
       if (uniqueKeys.has(test.key)) {
         throw new GraphBuilderError(
-          `Service multi execution test with key '${test.key}' already exists`,
+          `Service multi-execution test with key '${test.key}' already exists`,
         );
       }
       uniqueKeys.add(test.key);
@@ -139,14 +139,14 @@ export const V1_buildServiceTest = (
       });
       return keyedTest;
     });
-    // verify matching key values between multi execution and multi execution test
+    // verify matching key values between multi-execution and multi-execution test
     // NOTE: since test depends on execution, we want to check first if no test is found for an execution
     const testWithoutExecutionKeys = new Set(
       Array.from(uniqueKeys.values()).filter((key) => !executionKeys.has(key)),
     );
     Array.from(uniqueKeys.values()).forEach((key) => executionKeys.delete(key));
     /**
-     * Here, we verify matching key values between multi execution and multi test
+     * Here, we verify matching key values between multi-execution and multi test
      * NOTE: since test depends on execution, we definitely want to throw when no execution is found for a test.
      * The other direction is debatable, on one hand it makes sense to have a test for each execution, but very often
      * (and majorly for backward compatibility reasons) we have executions that only differ in connection information
@@ -191,7 +191,10 @@ const buildServiceExecutionRuntime = (
     mapping,
   );
   if (runtime instanceof V1_RuntimePointer) {
-    assertNonNullable(runtime.runtime, 'Runtime pointer path is missing');
+    assertNonNullable(
+      runtime.runtime,
+      `Runtime pointer 'runtime' field is missing`,
+    );
     return new RuntimePointer(context.resolveRuntime(runtime.runtime));
   } else if (runtime instanceof V1_EngineRuntime) {
     runtime.mappings = runtime.mappings.length
@@ -208,7 +211,7 @@ const buildServiceExecutionRuntime = (
     runtime.connections.forEach((connection) => {
       assertNonNullable(
         connection.store,
-        'Legacy runtime embedded connection store is missing',
+        `Legacy runtime embedded connection 'store' field is missing`,
       );
       const identifiedConnection = new V1_IdentifiedConnection();
       identifiedConnection.id = `connection_${idx} `;
@@ -240,7 +243,7 @@ export const V1_buildServiceExecution = (
   if (serviceExecution instanceof V1_PureSingleExecution) {
     assertNonNullable(
       serviceExecution.func,
-      'Service Pure execution function is missing',
+      `Service Pure execution 'func' field is missing`,
     );
     return new PureSingleExecution(
       V1_resolvePathsInRawLambda(
@@ -258,15 +261,15 @@ export const V1_buildServiceExecution = (
     );
   } else if (serviceExecution instanceof V1_PureMultiExecution) {
     if (!serviceExecution.executionParameters.length) {
-      throw new GraphBuilderError('Service multi execution must not be empty');
+      throw new GraphBuilderError('Service multi-execution must not be empty');
     }
     assertNonNullable(
       serviceExecution.func,
-      'Service Pure execution function is missing',
+      `Service Pure execution 'func' field is missing`,
     );
     assertNonEmptyString(
       serviceExecution.executionKey,
-      'Service multi execution key is missing',
+      `Service multi-execution 'executionKey' field is missing`,
     );
     const execution = new PureMultiExecution(
       serviceExecution.executionKey,
@@ -282,12 +285,12 @@ export const V1_buildServiceExecution = (
       (keyedExecutionParameter) => {
         assertNonEmptyString(
           keyedExecutionParameter.key,
-          'Service multi execution parameter key is missing',
+          `Service multi-execution parameter 'key' field is missing`,
         );
         // check duplicated key
         if (uniqueKeys.has(keyedExecutionParameter.key)) {
           throw new GraphBuilderError(
-            `Service multi execution with key '${keyedExecutionParameter.key}' already exists`,
+            `Service multi-execution with key '${keyedExecutionParameter.key}' already exists`,
           );
         }
         return new KeyedExecutionParameter(

package/src/models/protocols/pure/v1/transformation/pureProtocol/V1_PureProtocolSerialization.ts

@@ -102,7 +102,8 @@ const alloySdlcSerializationModelSchema = createModelSchema(V1_AlloySdlc, {
   _type: usingConstantValueSchema(V1_SdlcType.ALLOY),
   baseVersion: optional(primitive()),
   version: primitive(),
-  project: primitive(),
+  groupId: primitive(),
+  artifactId: primitive(),
   packageableElementPointers: list(
     usingModelSchema(V1_packageableElementPointerDeserializerSchema),
   ),

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_ConnectionSerializationHelper.ts

@@ -166,8 +166,13 @@ const snowflakeDatasourceSpecificationModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_DatasourceSpecificationType.SNOWFLAKE),
     accountName: primitive(),
+    accountType: optional(primitive()),
     cloudType: optional(primitive()),
     databaseName: primitive(),
+    nonProxyHosts: optional(primitive()),
+    organization: optional(primitive()),
+    proxyHost: optional(primitive()),
+    proxyPort: optional(primitive()),
     quotedIdentifiersIgnoreCase: optional(primitive()),
     region: primitive(),
     warehouseName: primitive(),

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_MappingSerializationHelper.ts

@@ -298,7 +298,6 @@ const otherwiseEmbeddedRelationalPropertyMappingModelSchgema =
       V1_PropertyMappingType.OTHERWISE_EMBEDDED_RELATIONAL,
     ),
     classMapping: usingModelSchema(relationalClassMappingModelSchema),
-    id: optional(primitive()),
     otherwisePropertyMapping: custom(
       (val) => V1_serializeRelationalPropertyMapping(val),
       (val) => V1_deserializeRelationalPropertyMapping(val),
@@ -347,8 +346,6 @@ function V1_serializeRelationalPropertyMapping(
 ): PlainObject<V1_PropertyMapping> | typeof SKIP {
   if (protocol instanceof V1_RelationalPropertyMapping) {
     return serialize(relationalPropertyMappingModelSchema, protocol);
-  } else if (protocol instanceof V1_EmbeddedRelationalPropertyMapping) {
-    return serialize(embeddedRelationalPropertyMappingModelSchema, protocol);
   } else if (
     protocol instanceof V1_OtherwiseEmbeddedRelationalPropertyMapping
   ) {
@@ -356,6 +353,8 @@ function V1_serializeRelationalPropertyMapping(
       otherwiseEmbeddedRelationalPropertyMappingModelSchgema,
       protocol,
     );
+  } else if (protocol instanceof V1_EmbeddedRelationalPropertyMapping) {
+    return serialize(embeddedRelationalPropertyMappingModelSchema, protocol);
   } else if (protocol instanceof V1_InlineEmbeddedPropertyMapping) {
     return serialize(inlineEmbeddedPropertyMappingModelSchema, protocol);
   } else if (protocol instanceof V1_XStorePropertyMapping) {