@finos/legend-extension-dsl-persistence 2.0.8 → 2.0.11

package/src/models/protocols/pure/DSLPersistence_PureProtocolProcessorPlugin.ts

@@ -16,13 +16,21 @@
 
 import packageJson from '../../../../package.json';
 import { Persistence } from '../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persistence.js';
+import { PersistenceContext } from '../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistenceContext.js';
 import { V1_Persistence } from './v1/model/packageableElements/persistence/V1_DSLPersistence_Persistence.js';
+import { V1_PersistenceContext } from './v1/model/packageableElements/persistence/V1_DSLPersistence_PersistenceContext.js';
 import {
   V1_PERSISTENCE_ELEMENT_PROTOCOL_TYPE,
   V1_persistenceModelSchema,
 } from './v1/transformation/pureProtocol/V1_DSLPersistence_ProtocolHelper.js';
+import {
+  V1_PERSISTENCE_CONTEXT_ELEMENT_PROTOCOL_TYPE,
+  V1_persistenceContextModelSchema,
+} from './v1/transformation/pureProtocol/V1_DSLPersistenceContext_ProtocolHelper.js';
 import { V1_buildPersistence } from './v1/transformation/pureGraph/to/V1_PersistenceBuilder.js';
+import { V1_buildPersistenceContext } from './v1/transformation/pureGraph/to/V1_PersistenceContextBuilder.js';
 import { V1_transformPersistence } from './v1/transformation/pureGraph/from/V1_PersistenceTransformer.js';
+import { V1_transformPersistenceContext } from './v1/transformation/pureGraph/from/V1_PersistenceContextTransformer.js';
 import {
   type PackageableElement,
   PureProtocolProcessorPlugin,
@@ -42,6 +50,9 @@ import { deserialize, serialize } from 'serializr';
 export const PERSISTENCE_ELEMENT_CLASSIFIER_PATH =
   'meta::pure::persistence::metamodel::Persistence';
 
+export const PERSISTENCE_CONTEXT_ELEMENT_CLASSIFIER_PATH =
+  'meta::pure::persistence::metamodel::PersistenceContext';
+
 export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
   constructor() {
     super(
@@ -80,6 +91,34 @@ export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProc
           V1_buildPersistence(elementProtocol, context);
         },
       }),
+      new V1_ElementBuilder<V1_PersistenceContext>({
+        elementClassName: 'PersistenceContext',
+        _class: V1_PersistenceContext,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(elementProtocol, V1_PersistenceContext);
+          const element = new PersistenceContext(elementProtocol.name);
+          const path = V1_buildFullPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            PersistenceContext,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(elementProtocol, V1_PersistenceContext);
+          V1_buildPersistenceContext(elementProtocol, context);
+        },
+      }),
     ];
   }
 
@@ -88,6 +127,8 @@ export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProc
       (elementProtocol: V1_PackageableElement): string | undefined => {
         if (elementProtocol instanceof V1_Persistence) {
           return PERSISTENCE_ELEMENT_CLASSIFIER_PATH;
+        } else if (elementProtocol instanceof V1_PersistenceContext) {
+          return PERSISTENCE_CONTEXT_ELEMENT_CLASSIFIER_PATH;
         }
         return undefined;
       },
@@ -102,6 +143,11 @@ export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProc
       ): PlainObject<V1_PackageableElement> | undefined => {
         if (elementProtocol instanceof V1_Persistence) {
           return serialize(V1_persistenceModelSchema(plugins), elementProtocol);
+        } else if (elementProtocol instanceof V1_PersistenceContext) {
+          return serialize(
+            V1_persistenceContextModelSchema(plugins),
+            elementProtocol,
+          );
         }
         return undefined;
       },
@@ -116,6 +162,10 @@ export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProc
       ): V1_PackageableElement | undefined => {
         if (json._type === V1_PERSISTENCE_ELEMENT_PROTOCOL_TYPE) {
           return deserialize(V1_persistenceModelSchema(plugins), json);
+        } else if (
+          json._type === V1_PERSISTENCE_CONTEXT_ELEMENT_PROTOCOL_TYPE
+        ) {
+          return deserialize(V1_persistenceContextModelSchema(plugins), json);
         }
         return undefined;
       },
@@ -130,6 +180,8 @@ export class DSLPersistence_PureProtocolProcessorPlugin extends PureProtocolProc
       ): V1_PackageableElement | undefined => {
         if (metamodel instanceof Persistence) {
           return V1_transformPersistence(metamodel, context);
+        } else if (metamodel instanceof PersistenceContext) {
+          return V1_transformPersistenceContext(metamodel, context);
         }
         return undefined;
       },

package/src/models/protocols/pure/DSLPersistence_PureProtocolProcessorPlugin_Extension.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { V1_PersistencePlatform } from './v1/model/packageableElements/persistence/V1_DSLPersistence_PersistencePlatform.js';
+import type { PersistencePlatform } from '../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistencePlatform.js';
+import type {
+  PureProtocolProcessorPlugin,
+  V1_GraphBuilderContext,
+  V1_GraphTransformerContext,
+} from '@finos/legend-graph';
+import type { PlainObject } from '@finos/legend-shared';
+
+// types: persistence platform
+
+export type V1_PersistencePlatformBuilder = (
+  protocol: V1_PersistencePlatform,
+  context: V1_GraphBuilderContext,
+) => PersistencePlatform | undefined;
+
+export type V1_PersistencePlatformTransformer = (
+  metamodel: PersistencePlatform,
+  context: V1_GraphTransformerContext,
+) => V1_PersistencePlatform | undefined;
+
+export type V1_PersistencePlatformProtocolSerializer = (
+  protocol: V1_PersistencePlatform,
+) => PlainObject<V1_PersistencePlatform> | undefined;
+
+export type V1_PersistencePlatformProtocolDeserializer = (
+  json: PlainObject<V1_PersistencePlatform>,
+) => V1_PersistencePlatform | undefined;
+
+export interface DSLPersistence_PureProtocolProcessorPlugin_Extension
+  extends PureProtocolProcessorPlugin {
+  // extension hooks: persistence platform
+
+  V1_getExtraPersistencePlatformBuilders?(): V1_PersistencePlatformBuilder[];
+
+  V1_getExtraPersistencePlatformTransformers?(): V1_PersistencePlatformTransformer[];
+
+  V1_getExtraPersistencePlatformProtocolSerializers?(): V1_PersistencePlatformProtocolSerializer[];
+
+  V1_getExtraPersistencePlatformProtocolDeserializers?(): V1_PersistencePlatformProtocolDeserializer[];
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_PersistenceContext.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../../DSLPersistence_ModelUtils.js';
+import type { V1_PersistencePlatform } from './V1_DSLPersistence_PersistencePlatform.js';
+import type { V1_ServiceParameter } from './V1_DSLPersistence_ServiceParameter.js';
+import {
+  type V1_Connection,
+  V1_PackageableElement,
+  type V1_PackageableElementVisitor,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export class V1_PersistenceContext
+  extends V1_PackageableElement
+  implements Hashable
+{
+  persistence!: string;
+  platform!: V1_PersistencePlatform;
+  serviceParameters: V1_ServiceParameter[] = [];
+  sinkConnection?: V1_Connection;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.PERSISTENCE_CONTEXT,
+      this.persistence,
+      this.platform,
+      hashArray(this.serviceParameters),
+      this.sinkConnection ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_PersistencePlatform.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../../DSLPersistence_ModelUtils.js';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export abstract class V1_PersistencePlatform implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_DefaultPersistencePlatform
+  extends V1_PersistencePlatform
+  implements Hashable
+{
+  override get hashCode(): string {
+    return hashArray([PERSISTENCE_HASH_STRUCTURE.DEFAULT_PERSISTENCE_PLATFORM]);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_ServiceParameter.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PERSISTENCE_HASH_STRUCTURE } from '../../../../../../DSLPersistence_ModelUtils.js';
+import type { V1_Connection, V1_ValueSpecification } from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+
+export class V1_ServiceParameter implements Hashable {
+  name!: string;
+  value!: V1_ServiceParameterValue;
+
+  get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.SERVICE_PARAMETER,
+      this.name,
+      this.value,
+    ]);
+  }
+}
+
+export abstract class V1_ServiceParameterValue implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_PrimitiveTypeValue
+  extends V1_ServiceParameterValue
+  implements Hashable
+{
+  primitiveType!: V1_ValueSpecification;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.PRIMITIVE_TYPE_VALUE_SERVICE_PARAMETER,
+      //TODO: ledav -- hash value specification
+    ]);
+  }
+}
+
+export class V1_ConnectionValue
+  extends V1_ServiceParameterValue
+  implements Hashable
+{
+  connection!: V1_Connection;
+
+  override get hashCode(): string {
+    return hashArray([
+      PERSISTENCE_HASH_STRUCTURE.CONNECTION_VALUE_SERVICE_PARAMETER,
+      this.connection,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/packageableElements/persistence/V1_DSLPersistence_Sink.ts

@@ -23,11 +23,15 @@ export abstract class V1_Sink implements Hashable {
 }
 
 export class V1_RelationalSink extends V1_Sink implements Hashable {
+  //TODO: ledav -- make required once persistence changes are rolled out in engine
+  database?: string;
+  //TODO: ledav -- remove once persistence changes are rolled out in engine
   connection?: V1_Connection;
 
   override get hashCode(): string {
     return hashArray([
       PERSISTENCE_HASH_STRUCTURE.RELATIONAL_SINK,
+      this.database ?? '',
       this.connection ?? '',
     ]);
   }
@@ -35,13 +39,14 @@ export class V1_RelationalSink extends V1_Sink implements Hashable {
 
 export class V1_ObjectStorageSink extends V1_Sink implements Hashable {
   binding!: string;
-  connection!: V1_Connection;
+  //TODO: ledav -- remove once persistence changes are rolled out in engine
+  connection?: V1_Connection;
 
   override get hashCode(): string {
     return hashArray([
       PERSISTENCE_HASH_STRUCTURE.OBJECT_STORAGE_SINK,
       this.binding,
-      this.connection,
+      this.connection ?? '',
     ]);
   }
 }

package/src/models/protocols/pure/v1/transformation/pureGraph/V1_DSLPersistence_GraphBuilderHelper.ts

@@ -15,7 +15,11 @@
  */
 
 import type { Persistence } from '../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persistence.js';
-import { getPersistence } from '../../../../../../graphManager/DSLPersistence_GraphManagerHelper.js';
+import type { PersistenceContext } from '../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistenceContext.js';
+import {
+  getPersistence,
+  getPersistenceContext,
+} from '../../../../../../graphManager/DSLPersistence_GraphManagerHelper.js';
 import type {
   PackageableElementImplicitReference,
   V1_GraphBuilderContext,
@@ -28,3 +32,11 @@ export const V1_resolvePersistence = (
   context.createImplicitPackageableElementReference(path, (_path: string) =>
     getPersistence(_path, context.graph),
   );
+
+export const V1_resolvePersistenceContext = (
+  path: string,
+  context: V1_GraphBuilderContext,
+): PackageableElementImplicitReference<PersistenceContext> =>
+  context.createImplicitPackageableElementReference(path, (_path: string) =>
+    getPersistenceContext(_path, context.graph),
+  );

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_PersistenceContextTransformer.ts

@@ -0,0 +1,141 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { PersistenceContext } from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistenceContext.js';
+import {
+  type PersistencePlatform,
+  DefaultPersistencePlatform,
+} from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistencePlatform.js';
+import {
+  ConnectionValue,
+  PrimitiveTypeValue,
+  type ServiceParameter,
+  type ServiceParameterValue,
+} from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_ServiceParameter.js';
+import { V1_PersistenceContext } from '../../../model/packageableElements/persistence/V1_DSLPersistence_PersistenceContext.js';
+import {
+  V1_DefaultPersistencePlatform,
+  type V1_PersistencePlatform,
+} from '../../../model/packageableElements/persistence/V1_DSLPersistence_PersistencePlatform.js';
+import {
+  V1_ConnectionValue,
+  V1_PrimitiveTypeValue,
+  V1_ServiceParameter,
+  type V1_ServiceParameterValue,
+} from '../../../model/packageableElements/persistence/V1_DSLPersistence_ServiceParameter.js';
+import type { DSLPersistence_PureProtocolProcessorPlugin_Extension } from '../../../../DSLPersistence_PureProtocolProcessorPlugin_Extension.js';
+import {
+  type V1_GraphTransformerContext,
+  V1_initPackageableElement,
+  V1_transformConnection,
+  V1_transformRootValueSpecification,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+/**********
+ * persistence platform
+ **********/
+
+export const V1_transformPersistencePlatform = (
+  element: PersistencePlatform,
+  context: V1_GraphTransformerContext,
+): V1_PersistencePlatform => {
+  if (element instanceof DefaultPersistencePlatform) {
+    return new V1_DefaultPersistencePlatform();
+  }
+  const extraPersistencePlatformTransformers = context.plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as DSLPersistence_PureProtocolProcessorPlugin_Extension
+      ).V1_getExtraPersistencePlatformTransformers?.() ?? [],
+  );
+  for (const transformer of extraPersistencePlatformTransformers) {
+    const protocol = transformer(element, context);
+    if (protocol) {
+      return protocol;
+    }
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform persistence platform: no compatible transformer available from plugins`,
+    element,
+  );
+};
+
+/**********
+ * service parameter
+ **********/
+
+export const V1_transformServiceParameterValue = (
+  element: ServiceParameterValue,
+  context: V1_GraphTransformerContext,
+): V1_ServiceParameterValue => {
+  if (element instanceof PrimitiveTypeValue) {
+    const protocol = new V1_PrimitiveTypeValue();
+    protocol.primitiveType = V1_transformRootValueSpecification(
+      element.primitiveType,
+    );
+    return protocol;
+  } else if (element instanceof ConnectionValue) {
+    const protocol = new V1_ConnectionValue();
+    protocol.connection = V1_transformConnection(
+      element.connection,
+      true,
+      context,
+    );
+    return protocol;
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform service parameter value '${element}'`,
+  );
+};
+
+export const V1_transformServiceParameter = (
+  element: ServiceParameter,
+  context: V1_GraphTransformerContext,
+): V1_ServiceParameter => {
+  const protocol = new V1_ServiceParameter();
+  protocol.name = element.name;
+  protocol.value = V1_transformServiceParameterValue(element.value, context);
+  return protocol;
+};
+
+/**********
+ * persistence context
+ **********/
+
+export const V1_transformPersistenceContext = (
+  element: PersistenceContext,
+  context: V1_GraphTransformerContext,
+): V1_PersistenceContext => {
+  const protocol = new V1_PersistenceContext();
+  V1_initPackageableElement(protocol, element);
+  protocol.persistence = element.persistence.valueForSerialization ?? '';
+  protocol.platform = V1_transformPersistencePlatform(
+    element.platform,
+    context,
+  );
+  protocol.serviceParameters = element.serviceParameters.map((sp) =>
+    V1_transformServiceParameter(sp, context),
+  );
+  if (element.sinkConnection) {
+    protocol.sinkConnection = V1_transformConnection(
+      element.sinkConnection,
+      true,
+      context,
+    );
+  }
+  return protocol;
+};

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_PersistenceTransformer.ts

@@ -192,6 +192,9 @@ export const V1_transformRelationalSink = (
   context: V1_GraphTransformerContext,
 ): V1_RelationalSink => {
   const protocol = new V1_RelationalSink();
+  if (element.database) {
+    protocol.database = element.database.value.path;
+  }
   if (element.connection) {
     protocol.connection = V1_transformConnection(
       element.connection,
@@ -207,12 +210,14 @@ export const V1_transformObjectStorageSink = (
   context: V1_GraphTransformerContext,
 ): V1_ObjectStorageSink => {
   const protocol = new V1_ObjectStorageSink();
-  protocol.connection = V1_transformConnection(
-    element.connection,
-    true,
-    context,
-  );
   protocol.binding = element.binding.value.path;
+  if (element.connection) {
+    protocol.connection = V1_transformConnection(
+      element.connection,
+      true,
+      context,
+    );
+  }
   return protocol;
 };
 
@@ -489,7 +494,7 @@ export const V1_transformFlatTarget = (
   context: V1_GraphTransformerContext,
 ): V1_FlatTarget => {
   const protocol = new V1_FlatTarget();
-  protocol.modelClass = element.modelClass.valueForSerialization;
+  protocol.modelClass = element.modelClass?.valueForSerialization;
   protocol.targetName = element.targetName;
   protocol.partitionFields = element.partitionFields;
   protocol.deduplicationStrategy = V1_transformDeduplicationStrategy(

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

@@ -156,11 +156,11 @@ import {
 import { getOwnPersistence } from '../../../../../../../graphManager/DSLPersistence_GraphManagerHelper.js';
 import {
   type Binding,
+  type Database,
   type PackageableElementImplicitReference,
   type V1_GraphBuilderContext,
-  V1_ProtocolToMetaModelConnectionBuilder,
   V1_buildFullPath,
-  optionalizePackageableElementReference,
+  V1_buildConnection,
 } from '@finos/legend-graph';
 import {
   guaranteeNonEmptyString,
@@ -198,10 +198,14 @@ export const V1_buildRelationalSink = (
   context: V1_GraphBuilderContext,
 ): RelationalSink => {
   const sink = new RelationalSink();
+  if (protocol.database) {
+    sink.database = context.resolveElement(
+      protocol.database,
+      false,
+    ) as PackageableElementImplicitReference<Database>;
+  }
   if (protocol.connection) {
-    sink.connection = protocol.connection.accept_ConnectionVisitor(
-      new V1_ProtocolToMetaModelConnectionBuilder(context),
-    );
+    sink.connection = V1_buildConnection(protocol.connection, context);
   }
   return sink;
 };
@@ -211,13 +215,13 @@ export const V1_buildObjectStorageSink = (
   context: V1_GraphBuilderContext,
 ): ObjectStorageSink => {
   const sink = new ObjectStorageSink();
-  sink.connection = protocol.connection.accept_ConnectionVisitor(
-    new V1_ProtocolToMetaModelConnectionBuilder(context),
-  );
   sink.binding = context.resolveElement(
     protocol.binding,
     false,
   ) as PackageableElementImplicitReference<Binding>;
+  if (protocol.connection) {
+    sink.connection = V1_buildConnection(protocol.connection, context);
+  }
   return sink;
 };
 
@@ -496,10 +500,9 @@ export const V1_buildFlatTarget = (
   context: V1_GraphBuilderContext,
 ): FlatTarget => {
   const targetShape = new FlatTarget();
-  targetShape.modelClass = optionalizePackageableElementReference(
-    modelClass ? context.resolveClass(modelClass) : undefined,
-  );
-
+  targetShape.modelClass = modelClass
+    ? context.resolveClass(modelClass)
+    : undefined;
   targetShape.targetName = guaranteeNonEmptyString(protocol.targetName);
   targetShape.partitionFields = protocol.partitionFields;
   targetShape.deduplicationStrategy = V1_buildDeduplicationStrategy(