io.github.vigoo.zioaws.redshiftdata.package.scala Maven / Gradle / Ivy

Go to download
package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.core.*
import io.github.vigoo.zioaws.core.aspects.*
import io.github.vigoo.zioaws.core.config.AwsConfig
import io.github.vigoo.zioaws.core.httpclient.ServiceHttpCapabilities
import software.amazon.awssdk.core.client.config.{ ClientAsyncConfiguration, SdkAdvancedAsyncClientOption }
import software.amazon.awssdk.services.redshiftdata.paginators.*
import software.amazon.awssdk.services.redshiftdata.{ RedshiftDataAsyncClient, RedshiftDataAsyncClientBuilder }
import zio.{ Chunk, Has, IO, URLayer, ZIO, ZLayer, ZManaged }
import zio.stream.ZStream
import org.reactivestreams.Publisher
import scala.jdk.CollectionConverters.*
package object redshiftdata {
  type RedshiftData = Has[RedshiftData.Service]
  object RedshiftData {
    trait Service extends AspectSupport[Service] {
      val api: RedshiftDataAsyncClient
      def listDatabases(request: model.ListDatabasesRequest): ZStream[Any, AwsError, String]
      def batchExecuteStatement(request: model.BatchExecuteStatementRequest): IO[AwsError, model.BatchExecuteStatementResponse.ReadOnly]
      def executeStatement(request: model.ExecuteStatementRequest): IO[AwsError, model.ExecuteStatementResponse.ReadOnly]
      def listStatements(request: model.ListStatementsRequest): ZStream[Any, AwsError, model.StatementData.ReadOnly]
      def listTables(request: model.ListTablesRequest): ZStream[Any, AwsError, model.TableMember.ReadOnly]
      def describeTable(request: model.DescribeTableRequest): ZIO[Any, AwsError, StreamingOutputResult[Any, model.DescribeTableResponse.ReadOnly, model.ColumnMetadata.ReadOnly]]
      def cancelStatement(request: model.CancelStatementRequest): IO[AwsError, model.CancelStatementResponse.ReadOnly]
      def getStatementResult(request: model.GetStatementResultRequest): zio.stream.ZStream[Any, AwsError, List[model.Field.ReadOnly]]
      def listSchemas(request: model.ListSchemasRequest): ZStream[Any, AwsError, String]
      def describeStatement(request: model.DescribeStatementRequest): IO[AwsError, model.DescribeStatementResponse.ReadOnly]
    }
    object RedshiftDataMock extends zio.test.mock.Mock[RedshiftData] {
      object ListDatabases extends Stream[model.ListDatabasesRequest, AwsError, String]
      object BatchExecuteStatement extends Effect[model.BatchExecuteStatementRequest, AwsError, model.BatchExecuteStatementResponse.ReadOnly]
      object ExecuteStatement extends Effect[model.ExecuteStatementRequest, AwsError, model.ExecuteStatementResponse.ReadOnly]
      object ListStatements extends Stream[model.ListStatementsRequest, AwsError, model.StatementData.ReadOnly]
      object ListTables extends Stream[model.ListTablesRequest, AwsError, model.TableMember.ReadOnly]
      object DescribeTable extends Effect[model.DescribeTableRequest, AwsError, StreamingOutputResult[Any, model.DescribeTableResponse.ReadOnly, model.ColumnMetadata.ReadOnly]]
      object CancelStatement extends Effect[model.CancelStatementRequest, AwsError, model.CancelStatementResponse.ReadOnly]
      object GetStatementResult extends Stream[model.GetStatementResultRequest, AwsError, List[model.Field.ReadOnly]]
      object ListSchemas extends Stream[model.ListSchemasRequest, AwsError, String]
      object DescribeStatement extends Effect[model.DescribeStatementRequest, AwsError, model.DescribeStatementResponse.ReadOnly]
      val compose: URLayer[Has[zio.test.mock.Proxy], RedshiftData] = ZLayer.fromServiceM {
        proxy => withRuntime.map {
          rts => new RedshiftData.Service {
            val api: RedshiftDataAsyncClient = null
            def withAspect[R1](newAspect: AwsCallAspect[R1], r: R1): RedshiftData.Service = this
            def listDatabases(request: model.ListDatabasesRequest): ZStream[Any, AwsError, String] = rts.unsafeRun(proxy(ListDatabases, request))
            def batchExecuteStatement(request: model.BatchExecuteStatementRequest): IO[AwsError, model.BatchExecuteStatementResponse.ReadOnly] = proxy(BatchExecuteStatement, request)
            def executeStatement(request: model.ExecuteStatementRequest): IO[AwsError, model.ExecuteStatementResponse.ReadOnly] = proxy(ExecuteStatement, request)
            def listStatements(request: model.ListStatementsRequest): ZStream[Any, AwsError, model.StatementData.ReadOnly] = rts.unsafeRun(proxy(ListStatements, request))
            def listTables(request: model.ListTablesRequest): ZStream[Any, AwsError, model.TableMember.ReadOnly] = rts.unsafeRun(proxy(ListTables, request))
            def describeTable(request: model.DescribeTableRequest): ZIO[Any, AwsError, StreamingOutputResult[Any, model.DescribeTableResponse.ReadOnly, model.ColumnMetadata.ReadOnly]] = proxy(DescribeTable, request)
            def cancelStatement(request: model.CancelStatementRequest): IO[AwsError, model.CancelStatementResponse.ReadOnly] = proxy(CancelStatement, request)
            def getStatementResult(request: model.GetStatementResultRequest): ZStream[Any, AwsError, List[model.Field.ReadOnly]] = rts.unsafeRun(proxy(GetStatementResult, request))
            def listSchemas(request: model.ListSchemasRequest): ZStream[Any, AwsError, String] = rts.unsafeRun(proxy(ListSchemas, request))
            def describeStatement(request: model.DescribeStatementRequest): IO[AwsError, model.DescribeStatementResponse.ReadOnly] = proxy(DescribeStatement, request)
          }
        }
      }
    }
  }
  val live: ZLayer[AwsConfig, Throwable, RedshiftData] = customized(identity)
  def customized(customization: RedshiftDataAsyncClientBuilder => RedshiftDataAsyncClientBuilder): ZLayer[AwsConfig, Throwable, RedshiftData] = managed(customization).toLayer
  def managed(customization: RedshiftDataAsyncClientBuilder => RedshiftDataAsyncClientBuilder): ZManaged[AwsConfig, Throwable, RedshiftData.Service] = for (awsConfig <- ZManaged.service[AwsConfig.Service]; executor <- ZIO.executor.toManaged_; builder = RedshiftDataAsyncClient.builder().asyncConfiguration(ClientAsyncConfiguration.builder().advancedOption(SdkAdvancedAsyncClientOption.FUTURE_COMPLETION_EXECUTOR, executor.asJava).build()); b0 <- awsConfig.configure[RedshiftDataAsyncClient, RedshiftDataAsyncClientBuilder](builder).toManaged_; b1 <- awsConfig.configureHttpClient[RedshiftDataAsyncClient, RedshiftDataAsyncClientBuilder](b0, ServiceHttpCapabilities(supportsHttp2 = false)).toManaged_; client <- ZIO(customization(b1).build()).toManaged_) yield new RedshiftDataImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])
  private class RedshiftDataImpl[R](override val api: RedshiftDataAsyncClient, override val aspect: AwsCallAspect[R], r: R) extends RedshiftData.Service with AwsServiceBase[R, RedshiftDataImpl] {
    override val serviceName: String = "RedshiftData"
    override def withAspect[R1](newAspect: AwsCallAspect[R1], r: R1): RedshiftDataImpl[R1] = new RedshiftDataImpl(api, newAspect, r)
    def listDatabases(request: model.ListDatabasesRequest): ZStream[Any, AwsError, String] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.ListDatabasesRequest, software.amazon.awssdk.services.redshiftdata.model.ListDatabasesResponse, java.lang.String]("listDatabases", api.listDatabases, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.databases().asScala))(request.buildAwsValue()).map(item => item: String).provide(r)
    def batchExecuteStatement(request: model.BatchExecuteStatementRequest): IO[AwsError, model.BatchExecuteStatementResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.redshiftdata.model.BatchExecuteStatementRequest, software.amazon.awssdk.services.redshiftdata.model.BatchExecuteStatementResponse]("batchExecuteStatement", api.batchExecuteStatement)(request.buildAwsValue()).map(model.BatchExecuteStatementResponse.wrap).provide(r)
    def executeStatement(request: model.ExecuteStatementRequest): IO[AwsError, model.ExecuteStatementResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementRequest, software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementResponse]("executeStatement", api.executeStatement)(request.buildAwsValue()).map(model.ExecuteStatementResponse.wrap).provide(r)
    def listStatements(request: model.ListStatementsRequest): ZStream[Any, AwsError, model.StatementData.ReadOnly] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.ListStatementsRequest, software.amazon.awssdk.services.redshiftdata.model.ListStatementsResponse, software.amazon.awssdk.services.redshiftdata.model.StatementData]("listStatements", api.listStatements, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.statements().asScala))(request.buildAwsValue()).map(item => model.StatementData.wrap(item)).provide(r)
    def listTables(request: model.ListTablesRequest): ZStream[Any, AwsError, model.TableMember.ReadOnly] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.ListTablesRequest, software.amazon.awssdk.services.redshiftdata.model.ListTablesResponse, software.amazon.awssdk.services.redshiftdata.model.TableMember]("listTables", api.listTables, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.tables().asScala))(request.buildAwsValue()).map(item => model.TableMember.wrap(item)).provide(r)
    def describeTable(request: model.DescribeTableRequest): ZIO[Any, AwsError, StreamingOutputResult[Any, model.DescribeTableResponse.ReadOnly, model.ColumnMetadata.ReadOnly]] = asyncPaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.DescribeTableRequest, software.amazon.awssdk.services.redshiftdata.model.DescribeTableResponse, software.amazon.awssdk.services.redshiftdata.model.ColumnMetadata]("describeTable", api.describeTable, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.columnList().asScala))(request.buildAwsValue()).map(result => result.mapResponse(model.DescribeTableResponse.wrap).mapOutput(_.map(item => model.ColumnMetadata.wrap(item))).provide(r)).provide(r)
    def cancelStatement(request: model.CancelStatementRequest): IO[AwsError, model.CancelStatementResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.redshiftdata.model.CancelStatementRequest, software.amazon.awssdk.services.redshiftdata.model.CancelStatementResponse]("cancelStatement", api.cancelStatement)(request.buildAwsValue()).map(model.CancelStatementResponse.wrap).provide(r)
    def getStatementResult(request: model.GetStatementResultRequest): zio.stream.ZStream[Any, AwsError, List[model.Field.ReadOnly]] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.GetStatementResultRequest, java.util.List[software.amazon.awssdk.services.redshiftdata.model.Field], software.amazon.awssdk.services.redshiftdata.paginators.GetStatementResultPublisher]("getStatementResult", api.getStatementResultPaginator, _.records())(request.buildAwsValue()).map(item => item.asScala.map { item => 
      model.Field.wrap(item)
    }.toList).provide(r)
    def listSchemas(request: model.ListSchemasRequest): ZStream[Any, AwsError, String] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.redshiftdata.model.ListSchemasRequest, software.amazon.awssdk.services.redshiftdata.model.ListSchemasResponse, java.lang.String]("listSchemas", api.listSchemas, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.schemas().asScala))(request.buildAwsValue()).map(item => item: String).provide(r)
    def describeStatement(request: model.DescribeStatementRequest): IO[AwsError, model.DescribeStatementResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.redshiftdata.model.DescribeStatementRequest, software.amazon.awssdk.services.redshiftdata.model.DescribeStatementResponse]("describeStatement", api.describeStatement)(request.buildAwsValue()).map(model.DescribeStatementResponse.wrap).provide(r)
  }
  def listDatabases(request: model.ListDatabasesRequest): ZStream[RedshiftData, AwsError, String] = ZStream.accessStream(_.get.listDatabases(request))
  def batchExecuteStatement(request: model.BatchExecuteStatementRequest): ZIO[RedshiftData, AwsError, model.BatchExecuteStatementResponse.ReadOnly] = ZIO.accessM(_.get.batchExecuteStatement(request))
  def executeStatement(request: model.ExecuteStatementRequest): ZIO[RedshiftData, AwsError, model.ExecuteStatementResponse.ReadOnly] = ZIO.accessM(_.get.executeStatement(request))
  def listStatements(request: model.ListStatementsRequest): ZStream[RedshiftData, AwsError, model.StatementData.ReadOnly] = ZStream.accessStream(_.get.listStatements(request))
  def listTables(request: model.ListTablesRequest): ZStream[RedshiftData, AwsError, model.TableMember.ReadOnly] = ZStream.accessStream(_.get.listTables(request))
  def describeTable(request: model.DescribeTableRequest): ZIO[RedshiftData, AwsError, StreamingOutputResult[Any, model.DescribeTableResponse.ReadOnly, model.ColumnMetadata.ReadOnly]] = ZIO.accessM(_.get.describeTable(request))
  def cancelStatement(request: model.CancelStatementRequest): ZIO[RedshiftData, AwsError, model.CancelStatementResponse.ReadOnly] = ZIO.accessM(_.get.cancelStatement(request))
  def getStatementResult(request: model.GetStatementResultRequest): zio.stream.ZStream[RedshiftData, AwsError, List[model.Field.ReadOnly]] = ZStream.accessStream(_.get.getStatementResult(request))
  def listSchemas(request: model.ListSchemasRequest): ZStream[RedshiftData, AwsError, String] = ZStream.accessStream(_.get.listSchemas(request))
  def describeStatement(request: model.DescribeStatementRequest): ZIO[RedshiftData, AwsError, model.DescribeStatementResponse.ReadOnly] = ZIO.accessM(_.get.describeStatement(request))
}