@finos/legend-extension-dsl-persistence 2.0.9 → 2.0.10

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;
 };
 

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

@@ -156,6 +156,7 @@ import {
 import { getOwnPersistence } from '../../../../../../../graphManager/DSLPersistence_GraphManagerHelper.js';
 import {
   type Binding,
+  type Database,
   type PackageableElementImplicitReference,
   type V1_GraphBuilderContext,
   V1_ProtocolToMetaModelConnectionBuilder,
@@ -198,6 +199,12 @@ 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),
@@ -211,13 +218,15 @@ 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 = protocol.connection.accept_ConnectionVisitor(
+      new V1_ProtocolToMetaModelConnectionBuilder(context),
+    );
+  }
   return sink;
 };
 

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

@@ -0,0 +1,151 @@
+/**
+ * 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_PersistenceContext } from '../../../model/packageableElements/persistence/V1_DSLPersistence_PersistenceContext.js';
+import {
+  type V1_PersistencePlatform,
+  V1_DefaultPersistencePlatform,
+} from '../../../model/packageableElements/persistence/V1_DSLPersistence_PersistencePlatform.js';
+import {
+  V1_ConnectionValue,
+  V1_PrimitiveTypeValue,
+  type V1_ServiceParameter,
+  type V1_ServiceParameterValue,
+} from '../../../model/packageableElements/persistence/V1_DSLPersistence_ServiceParameter.js';
+import type { Persistence } from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_Persistence.js';
+import {
+  DefaultPersistencePlatform,
+  type PersistencePlatform,
+} from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_PersistencePlatform.js';
+import {
+  ConnectionValue,
+  PrimitiveTypeValue,
+  ServiceParameter,
+  type ServiceParameterValue,
+} from '../../../../../../metamodels/pure/model/packageableElements/persistence/DSLPersistence_ServiceParameter.js';
+import { getOwnPersistenceContext } from '../../../../../../../graphManager/DSLPersistence_GraphManagerHelper.js';
+import type { DSLPersistence_PureProtocolProcessorPlugin_Extension } from '../../../../DSLPersistence_PureProtocolProcessorPlugin_Extension.js';
+import {
+  type PackageableElementImplicitReference,
+  V1_buildFullPath,
+  V1_buildValueSpecification,
+  type V1_GraphBuilderContext,
+  V1_ProtocolToMetaModelConnectionBuilder,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+/**********
+ * persistence platform
+ **********/
+
+export const V1_buildPersistencePlatform = (
+  protocol: V1_PersistencePlatform,
+  context: V1_GraphBuilderContext,
+): PersistencePlatform => {
+  if (protocol instanceof V1_DefaultPersistencePlatform) {
+    return new DefaultPersistencePlatform();
+  }
+  const extraPersistencePlatformBuilders = context.extensions.plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as DSLPersistence_PureProtocolProcessorPlugin_Extension
+      ).V1_getExtraPersistencePlatformBuilders?.() ?? [],
+  );
+  for (const builder of extraPersistencePlatformBuilders) {
+    const metamodel = builder(protocol, context);
+    if (metamodel) {
+      return metamodel;
+    }
+  }
+  throw new UnsupportedOperationError(
+    `Can't build persistence platform: no compatible builder available from plugins`,
+    protocol,
+  );
+};
+
+/**********
+ * service parameter
+ **********/
+
+export const V1_buildServiceParameterValue = (
+  protocol: V1_ServiceParameterValue,
+  context: V1_GraphBuilderContext,
+): ServiceParameterValue => {
+  if (protocol instanceof V1_PrimitiveTypeValue) {
+    const serviceParameterValue = new PrimitiveTypeValue();
+    serviceParameterValue.primitiveType = V1_buildValueSpecification(
+      protocol.primitiveType,
+      context,
+    );
+    return serviceParameterValue;
+  } else if (protocol instanceof V1_ConnectionValue) {
+    const serviceParameterValue = new ConnectionValue();
+    serviceParameterValue.connection =
+      protocol.connection.accept_ConnectionVisitor(
+        new V1_ProtocolToMetaModelConnectionBuilder(context),
+      );
+    return serviceParameterValue;
+  }
+  throw new UnsupportedOperationError(
+    `Can't build service parameter value`,
+    protocol,
+  );
+};
+
+export const V1_buildServiceParameter = (
+  protocol: V1_ServiceParameter,
+  context: V1_GraphBuilderContext,
+): ServiceParameter => {
+  const serviceParameter = new ServiceParameter();
+  serviceParameter.name = protocol.name;
+  serviceParameter.value = V1_buildServiceParameterValue(
+    protocol.value,
+    context,
+  );
+  return serviceParameter;
+};
+
+/**********
+ * persistence context
+ **********/
+
+export const V1_buildPersistenceContext = (
+  protocol: V1_PersistenceContext,
+  context: V1_GraphBuilderContext,
+): void => {
+  const path = V1_buildFullPath(protocol.package, protocol.name);
+  const persistenceContext = getOwnPersistenceContext(
+    path,
+    context.currentSubGraph,
+  );
+  persistenceContext.persistence = context.resolveElement(
+    protocol.persistence,
+    false,
+  ) as PackageableElementImplicitReference<Persistence>;
+  persistenceContext.platform = V1_buildPersistencePlatform(
+    protocol.platform,
+    context,
+  );
+  persistenceContext.serviceParameters = protocol.serviceParameters.map((sp) =>
+    V1_buildServiceParameter(sp, context),
+  );
+  if (protocol.sinkConnection) {
+    persistenceContext.sinkConnection =
+      protocol.sinkConnection.accept_ConnectionVisitor(
+        new V1_ProtocolToMetaModelConnectionBuilder(context),
+      );
+  }
+};

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

@@ -0,0 +1,242 @@
+/**
+ * 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 { 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 PureProtocolProcessorPlugin,
+  V1_deserializeConnectionValue,
+  V1_deserializeValueSpecification,
+  V1_serializeConnectionValue,
+  V1_serializeValueSpecification,
+} from '@finos/legend-graph';
+import {
+  deserializeArray,
+  type PlainObject,
+  serializeArray,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  type ModelSchema,
+  primitive,
+  serialize,
+  SKIP,
+} from 'serializr';
+
+/**********
+ * persistence platfrom
+ **********/
+
+enum V1_PersistencePlatformType {
+  DEFAULT = 'default',
+}
+
+const V1_defaultPersistencePlatformModelSchema = createModelSchema(
+  V1_DefaultPersistencePlatform,
+  {
+    _type: usingConstantValueSchema(V1_PersistencePlatformType.DEFAULT),
+  },
+);
+
+export const V1_serializePersistencePlatform = (
+  protocol: V1_PersistencePlatform,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_PersistencePlatform> => {
+  if (protocol instanceof V1_DefaultPersistencePlatform) {
+    return serialize(V1_defaultPersistencePlatformModelSchema, protocol);
+  }
+  const extraPersistencePlatformProtocolSerializers = plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as DSLPersistence_PureProtocolProcessorPlugin_Extension
+      ).V1_getExtraPersistencePlatformProtocolSerializers?.() ?? [],
+  );
+  for (const serializer of extraPersistencePlatformProtocolSerializers) {
+    const persistencePlatformProtocolJson = serializer(protocol);
+    if (persistencePlatformProtocolJson) {
+      return persistencePlatformProtocolJson;
+    }
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize persistence platform: no compatible serializer available from plugins`,
+    protocol,
+  );
+};
+
+export const V1_deserializePersistencePlatform = (
+  json: PlainObject<V1_PersistencePlatform>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_PersistencePlatform => {
+  switch (json._type) {
+    case V1_PersistencePlatformType.DEFAULT:
+      return deserialize(V1_defaultPersistencePlatformModelSchema, json);
+    default: {
+      const extraPersistencePlatformProtocolDeserializers = plugins.flatMap(
+        (plugin) =>
+          (
+            plugin as DSLPersistence_PureProtocolProcessorPlugin_Extension
+          ).V1_getExtraPersistencePlatformProtocolDeserializers?.() ?? [],
+      );
+      for (const deserializer of extraPersistencePlatformProtocolDeserializers) {
+        const persistencePlatformProtocol = deserializer(json);
+        if (persistencePlatformProtocol) {
+          return persistencePlatformProtocol;
+        }
+      }
+      throw new UnsupportedOperationError(
+        `Can't deserialize persistence platform of type '${json._type}': no compatible deserializer available from plugins`,
+      );
+    }
+  }
+};
+
+/**********
+ * service parameters
+ **********/
+
+enum V1_ServiceParameterValueType {
+  PRIMITIVE_TYPE_VALUE = 'primitiveTypeValue',
+  CONNECTION_VALUE = 'connectionValue',
+}
+
+const V1_primitiveTypeValueModelSchema = createModelSchema(
+  V1_PrimitiveTypeValue,
+  {
+    _type: usingConstantValueSchema(
+      V1_ServiceParameterValueType.PRIMITIVE_TYPE_VALUE,
+    ),
+    primitiveType: custom(
+      (val) => V1_serializeValueSpecification(val),
+      (val) => V1_deserializeValueSpecification(val),
+    ),
+  },
+);
+
+const V1_connectionValueModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_ConnectionValue> =>
+  createModelSchema(V1_ConnectionValue, {
+    _type: usingConstantValueSchema(
+      V1_ServiceParameterValueType.CONNECTION_VALUE,
+    ),
+    connection: custom(
+      (val) => (val ? V1_serializeConnectionValue(val, true, plugins) : SKIP),
+      (val) => V1_deserializeConnectionValue(val, true, plugins),
+    ),
+  });
+
+export const V1_serializeServiceParameterValue = (
+  protocol: V1_ServiceParameterValue,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_ServiceParameterValue> => {
+  if (protocol instanceof V1_PrimitiveTypeValue) {
+    return serialize(V1_primitiveTypeValueModelSchema, protocol);
+  } else if (protocol instanceof V1_ConnectionValue) {
+    return serialize(V1_connectionValueModelSchema(plugins), protocol);
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize service parameter value`,
+    protocol,
+  );
+};
+
+export const V1_deserializeServiceParameterValue = (
+  json: PlainObject<V1_ServiceParameterValue>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_ServiceParameterValue => {
+  switch (json._type) {
+    case V1_ServiceParameterValueType.PRIMITIVE_TYPE_VALUE:
+      return deserialize(V1_primitiveTypeValueModelSchema, json);
+    case V1_ServiceParameterValueType.CONNECTION_VALUE:
+      return deserialize(V1_connectionValueModelSchema(plugins), json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize service parameter value '${json._type}'`,
+      );
+  }
+};
+
+const V1_serviceParameterModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_ServiceParameter> =>
+  createModelSchema(V1_ServiceParameter, {
+    name: primitive(),
+    value: custom(
+      (val) => V1_serializeServiceParameterValue(val, plugins),
+      (val) => V1_deserializeServiceParameterValue(val, plugins),
+    ),
+  });
+
+/**********
+ * persistence context
+ **********/
+
+export const V1_PERSISTENCE_CONTEXT_ELEMENT_PROTOCOL_TYPE =
+  'persistenceContext';
+
+export const V1_persistenceContextModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_PersistenceContext> =>
+  createModelSchema(V1_PersistenceContext, {
+    _type: usingConstantValueSchema(
+      V1_PERSISTENCE_CONTEXT_ELEMENT_PROTOCOL_TYPE,
+    ),
+    name: primitive(),
+    package: primitive(),
+    persistence: primitive(),
+    platform: custom(
+      (val) => V1_serializePersistencePlatform(val, plugins),
+      (val) => V1_deserializePersistencePlatform(val, plugins),
+    ),
+    serviceParameters: custom(
+      (val) =>
+        serializeArray(
+          val,
+          (v: V1_ServiceParameter) =>
+            serialize(V1_serviceParameterModelSchema(plugins), v),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
+        ),
+      (val) =>
+        deserializeArray(
+          val,
+          (v) => deserialize(V1_serviceParameterModelSchema(plugins), v),
+          {
+            skipIfEmpty: false,
+          },
+        ),
+    ),
+    sinkConnection: custom(
+      (val) => (val ? V1_serializeConnectionValue(val, true, plugins) : SKIP),
+      (val) => V1_deserializeConnectionValue(val, true, plugins),
+    ),
+  });

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

@@ -15,29 +15,6 @@
  */
 
 import { V1_Persistence } from '../../model/packageableElements/persistence/V1_DSLPersistence_Persistence.js';
-import {
-  type PureProtocolProcessorPlugin,
-  V1_deserializeConnectionValue,
-  V1_serializeConnectionValue,
-} from '@finos/legend-graph';
-import {
-  deserializeArray,
-  type PlainObject,
-  serializeArray,
-  UnsupportedOperationError,
-  usingConstantValueSchema,
-} from '@finos/legend-shared';
-import {
-  createModelSchema,
-  custom,
-  deserialize,
-  list,
-  type ModelSchema,
-  optional,
-  primitive,
-  serialize,
-  SKIP,
-} from 'serializr';
 import {
   V1_CronTrigger,
   V1_ManualTrigger,
@@ -106,6 +83,25 @@ import {
   type V1_Persister,
   V1_StreamingPersister,
 } from '../../model/packageableElements/persistence/V1_DSLPersistence_Persister.js';
+import type { PureProtocolProcessorPlugin } from '@finos/legend-graph';
+import {
+  deserializeArray,
+  type PlainObject,
+  serializeArray,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  type ModelSchema,
+  optional,
+  primitive,
+  serialize,
+  SKIP,
+} from 'serializr';
 
 /**********
  * notifier
@@ -695,10 +691,7 @@ const V1_relationalSinkModelSchema = (
 ): ModelSchema<V1_RelationalSink> =>
   createModelSchema(V1_RelationalSink, {
     _type: usingConstantValueSchema(V1_SinkType.RELATIONAL_SINK),
-    connection: custom(
-      (val) => (val ? V1_serializeConnectionValue(val, true, plugins) : SKIP),
-      (val) => V1_deserializeConnectionValue(val, true, plugins),
-    ),
+    database: optional(primitive()),
   });
 
 const V1_objectStorageSinkModelSchema = (
@@ -707,10 +700,6 @@ const V1_objectStorageSinkModelSchema = (
   createModelSchema(V1_ObjectStorageSink, {
     _type: usingConstantValueSchema(V1_SinkType.OBJECT_STORAGE_SINK),
     binding: optional(primitive()),
-    connection: custom(
-      (val) => V1_serializeConnectionValue(val, true, plugins),
-      (val) => V1_deserializeConnectionValue(val, true, plugins),
-    ),
   });
 
 export const V1_serializeSink = (