Break circular dependencies

delta/app/src/main/scala/ch/epfl/bluebrain/nexus/delta/wiring/ResourcesModule.scala

@@ -19,18 +19,23 @@ import ch.epfl.bluebrain.nexus.delta.sdk.projects.FetchContext
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ApiMappings
 import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.ResolverResolution.ResourceResolution
 import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.{ResolverContextResolution, Resolvers, ResourceResolution}
+import ch.epfl.bluebrain.nexus.delta.sdk.resources.Resources.{ResourceDefinition, ResourceLog}
+import ch.epfl.bluebrain.nexus.delta.sdk.resources._
 import ch.epfl.bluebrain.nexus.delta.sdk.resources.model.{Resource, ResourceEvent}
-import ch.epfl.bluebrain.nexus.delta.sdk.resources.{DetectChange, Resources, ResourcesConfig, ResourcesImpl, ValidateResource}
-import ch.epfl.bluebrain.nexus.delta.sdk.schemas.Schemas
+import ch.epfl.bluebrain.nexus.delta.sdk.schemas.FetchSchema
 import ch.epfl.bluebrain.nexus.delta.sdk.schemas.model.Schema
 import ch.epfl.bluebrain.nexus.delta.sdk.sse.SseEncoder
-import ch.epfl.bluebrain.nexus.delta.sourcing.Transactors
+import ch.epfl.bluebrain.nexus.delta.sourcing.{ScopedEventLog, Transactors}
 import izumi.distage.model.definition.{Id, ModuleDef}
 
 /**
  * Resources wiring
  */
 object ResourcesModule extends ModuleDef {
+ make[ResourceResolution[Schema]].from { (aclCheck: AclCheck, resolvers: Resolvers, fetchSchema: FetchSchema) =>
+ ResourceResolution.schemaResource(aclCheck, resolvers, fetchSchema, excludeDeprecated = false)
+ }
+
  make[ValidateResource].from {
  (resourceResolution: ResourceResolution[Schema], rcr: RemoteContextResolution @Id("aggregate")) =>
  ValidateResource(resourceResolution)(rcr)
@@ -40,39 +45,40 @@ object ResourcesModule extends ModuleDef {
 
  make[DetectChange].from { (config: ResourcesConfig) => DetectChange(config.skipUpdateNoChange) }
 
+ make[ResourceDefinition].from { (validateResource: ValidateResource, detectChange: DetectChange, clock: Clock[IO]) =>
+ Resources.definition(validateResource, detectChange, clock)
+ }
+
+ make[ResourceLog].from { (scopedDefinition: ResourceDefinition, config: ResourcesConfig, xas: Transactors) =>
+ ScopedEventLog(scopedDefinition, config.eventLog, xas)
+ }
+
  make[Resources].from {
  (
- validate: ValidateResource,
- detectChange: DetectChange,
+ resourceLog: ResourceLog,
  fetchContext: FetchContext,
- config: ResourcesConfig,
  resolverContextResolution: ResolverContextResolution,
  api: JsonLdApi,
- xas: Transactors,
- clock: Clock[IO],
  uuidF: UUIDF
  ) =>
  ResourcesImpl(
- validate,
- detectChange,
+ resourceLog,
  fetchContext,
- resolverContextResolution,
- config,
- xas,
- clock
+ resolverContextResolution
  )(
  api,
  uuidF
  )
  }
 
  make[ResolverContextResolution].from {
- (aclCheck: AclCheck, resolvers: Resolvers, resources: Resources, rcr: RemoteContextResolution @Id("aggregate")) =>
- ResolverContextResolution(aclCheck, resolvers, resources, rcr)
- }
-
- make[ResourceResolution[Schema]].from { (aclCheck: AclCheck, resolvers: Resolvers, schemas: Schemas) =>
- ResourceResolution.schemaResource(aclCheck, resolvers, schemas, excludeDeprecated = false)
+ (
+ aclCheck: AclCheck,
+ resolvers: Resolvers,
+ rcr: RemoteContextResolution @Id("aggregate"),
+ fetchResource: FetchResource
+ ) =>
+ ResolverContextResolution(aclCheck, resolvers, rcr, fetchResource)
  }
 
  make[ResourcesRoutes].from {

delta/app/src/main/scala/ch/epfl/bluebrain/nexus/delta/wiring/SchemasModule.scala

@@ -21,11 +21,12 @@ import ch.epfl.bluebrain.nexus.delta.sdk.model.metrics.ScopedEventMetricEncoder
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.FetchContext
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ApiMappings
 import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.{ResolverContextResolution, Resolvers}
-import ch.epfl.bluebrain.nexus.delta.sdk.resources.Resources
+import ch.epfl.bluebrain.nexus.delta.sdk.resources.FetchResource
+import ch.epfl.bluebrain.nexus.delta.sdk.schemas.Schemas.{SchemaDefinition, SchemaLog}
+import ch.epfl.bluebrain.nexus.delta.sdk.schemas._
 import ch.epfl.bluebrain.nexus.delta.sdk.schemas.model.{Schema, SchemaEvent}
-import ch.epfl.bluebrain.nexus.delta.sdk.schemas.{SchemaImports, Schemas, SchemasImpl, ValidateSchema}
 import ch.epfl.bluebrain.nexus.delta.sdk.sse.SseEncoder
-import ch.epfl.bluebrain.nexus.delta.sourcing.Transactors
+import ch.epfl.bluebrain.nexus.delta.sourcing.{ScopedEventLog, Transactors}
 import izumi.distage.model.definition.{Id, ModuleDef}
 
 /**
@@ -40,37 +41,43 @@ object SchemasModule extends ModuleDef {
 
  }
 
+ make[SchemaDefinition].from { (validateSchema: ValidateSchema, clock: Clock[IO]) =>
+ Schemas.definition(validateSchema, clock)
+ }
+
+ make[SchemaLog].from { (scopedDefinition: SchemaDefinition, config: AppConfig, xas: Transactors) =>
+ ScopedEventLog(scopedDefinition, config.schemas.eventLog, xas)
+ }
+
+ make[FetchSchema].from { (schemaLog: SchemaLog) =>
+ FetchSchema(schemaLog)
+ }
+
  make[Schemas].from {
  (
+ schemaLog: SchemaLog,
  fetchContext: FetchContext,
  schemaImports: SchemaImports,
  api: JsonLdApi,
- validate: ValidateSchema,
  resolverContextResolution: ResolverContextResolution,
- config: AppConfig,
- xas: Transactors,
- clock: Clock[IO],
  uuidF: UUIDF
  ) =>
  SchemasImpl(
+ schemaLog,
  fetchContext,
  schemaImports,
- resolverContextResolution,
- validate,
- config.schemas,
- xas,
- clock
+ resolverContextResolution
  )(api, uuidF)
  }
 
  make[SchemaImports].from {
  (
  aclCheck: AclCheck,
  resolvers: Resolvers,
- resources: Resources,
- schemas: Schemas
+ fetchSchema: FetchSchema,
+ fetchResource: FetchResource
  ) =>
- SchemaImports(aclCheck, resolvers, schemas, resources)
+ SchemaImports(aclCheck, resolvers, fetchSchema, fetchResource)
  }
 
  make[SchemasRoutes].from {

delta/app/src/test/scala/ch/epfl/bluebrain/nexus/delta/routes/ResourcesRoutesSpec.scala

@@ -17,16 +17,17 @@ import ch.epfl.bluebrain.nexus.delta.sdk.generators.{ProjectGen, ResourceResolut
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.IdentitiesDummy
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.model.Caller
 import ch.epfl.bluebrain.nexus.delta.sdk.implicits._
+import ch.epfl.bluebrain.nexus.delta.sdk.model.Fetch.FetchF
 import ch.epfl.bluebrain.nexus.delta.sdk.model.{IdSegmentRef, ResourceUris}
 import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.resources
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.FetchContextDummy
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ApiMappings
 import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.ResolverContextResolution
-import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.ResolverResolution.FetchResource
 import ch.epfl.bluebrain.nexus.delta.sdk.resources.NexusSource.DecodingOption
-import ch.epfl.bluebrain.nexus.delta.sdk.resources.{DetectChange, Resources, ResourcesConfig, ResourcesImpl, ValidateResource}
+import ch.epfl.bluebrain.nexus.delta.sdk.resources._
 import ch.epfl.bluebrain.nexus.delta.sdk.schemas.model.Schema
 import ch.epfl.bluebrain.nexus.delta.sdk.utils.BaseRouteSpec
+import ch.epfl.bluebrain.nexus.delta.sourcing.ScopedEventLog
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Identity.{Anonymous, Authenticated, Group, Subject, User}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Tag.UserTag
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.{ProjectRef, ResourceRef}
@@ -87,7 +88,7 @@ class ResourcesRoutesSpec extends BaseRouteSpec with CatsIOValues {
 
  private val aclCheck = AclSimpleCheck().accepted
 
- private val fetchSchema: (ResourceRef, ProjectRef) => FetchResource[Schema] = {
+ private val fetchSchema: (ResourceRef, ProjectRef) => FetchF[Schema] = {
  case (ref, _) if ref.iri == schema2.id => IO.pure(Some(SchemaGen.resourceFor(schema2, deprecated = true)))
  case (ref, _) if ref.iri == schema1.id => IO.pure(Some(SchemaGen.resourceFor(schema1)))
  case (ref, _) if ref.iri == schema3.id => IO.pure(Some(SchemaGen.resourceFor(schema3)))
@@ -101,14 +102,17 @@ class ResourcesRoutesSpec extends BaseRouteSpec with CatsIOValues {
  private val resolverContextResolution: ResolverContextResolution = ResolverContextResolution(rcr)
 
  private def routesWithDecodingOption(implicit decodingOption: DecodingOption): (Route, Resources) = {
+ val resourceDef = Resources.definition(validator, DetectChange(enabled = true), clock)
+ val scopedLog = ScopedEventLog(
+ resourceDef,
+ ResourcesConfig(eventLogConfig, decodingOption, skipUpdateNoChange = true).eventLog,
+ xas
+ )
+
  val resources = ResourcesImpl(
- validator,
- DetectChange(enabled = true),
+ scopedLog,
  fetchContext,
- resolverContextResolution,
- ResourcesConfig(eventLogConfig, decodingOption, skipUpdateNoChange = true),
- xas,
- clock
+ resolverContextResolution
  )
  (
  Route.seal(

delta/app/src/test/scala/ch/epfl/bluebrain/nexus/delta/routes/SchemasRoutesSpec.scala

@@ -23,8 +23,9 @@ import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.schemas
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.FetchContextDummy
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ApiMappings
 import ch.epfl.bluebrain.nexus.delta.sdk.resolvers.ResolverContextResolution
-import ch.epfl.bluebrain.nexus.delta.sdk.schemas.{SchemaImports, SchemasConfig, SchemasImpl, ValidateSchema}
+import ch.epfl.bluebrain.nexus.delta.sdk.schemas.{SchemaImports, Schemas, SchemasConfig, SchemasImpl, ValidateSchema}
 import ch.epfl.bluebrain.nexus.delta.sdk.utils.BaseRouteSpec
+import ch.epfl.bluebrain.nexus.delta.sourcing.ScopedEventLog
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Identity.{Anonymous, Authenticated, Group, Subject, User}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.ProjectRef
 import ch.epfl.bluebrain.nexus.testkit.ce.IOFromMap
@@ -78,12 +79,15 @@ class SchemasRoutesSpec extends BaseRouteSpec with IOFromMap with CatsIOValues {
 
  private val config = SchemasConfig(eventLogConfig)
 
+ private val schemaDef = Schemas.definition(ValidateSchema.apply, clock)
+ private lazy val schemaLog = ScopedEventLog(schemaDef, config.eventLog, xas)
+
  private lazy val routes =
  Route.seal(
  SchemasRoutes(
  identities,
  aclCheck,
- SchemasImpl(fetchContext, schemaImports, resolverContextResolution, ValidateSchema.apply, config, xas, clock),
+ SchemasImpl(schemaLog, fetchContext, schemaImports, resolverContextResolution),
  groupDirectives,
  IndexingAction.noop
  )

delta/plugins/blazegraph/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/blazegraph/BlazegraphViews.scala

@@ -480,14 +480,12 @@ object BlazegraphViews {
  BlazegraphViewCommand,
  BlazegraphViewEvent,
  BlazegraphViewRejection
- ] =
+ ] = {
+ val stateMachine = StateMachine(None, next)
+ val evaluator = CommandEvaluator(stateMachine, evaluate(validate, clock))
  ScopedEntityDefinition.untagged(
  entityType,
- StateMachine(
- None,
- evaluate(validate, clock),
- next
- ),
+ evaluator,
  BlazegraphViewEvent.serializer,
  BlazegraphViewState.serializer,
  { s =>
@@ -503,6 +501,7 @@ object BlazegraphViews {
  case c => IncorrectRev(c.rev, c.rev + 1)
  }
  )
+ }
 
  /**
  * Constructs a [[BlazegraphViews]] instance.

delta/plugins/composite-views/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/compositeviews/CompositeViews.scala

@@ -442,10 +442,18 @@ object CompositeViews {
 
  def definition(validate: ValidateCompositeView, clock: Clock[IO])(implicit
  uuidF: UUIDF
- ): ScopedEntityDefinition[Iri, CompositeViewState, CompositeViewCommand, CompositeViewEvent, CompositeViewRejection] =
+ ): ScopedEntityDefinition[
+ Iri,
+ CompositeViewState,
+ CompositeViewCommand,
+ CompositeViewEvent,
+ CompositeViewRejection
+ ] = {
+ val stateMachine = StateMachine(None, next)
+ val evaluator = CommandEvaluator(stateMachine, evaluate(validate, clock))
  ScopedEntityDefinition.untagged(
  entityType,
- StateMachine(None, evaluate(validate, clock)(_, _), next),
+ evaluator,
  CompositeViewEvent.serializer,
  CompositeViewState.serializer,
  state =>
@@ -462,6 +470,7 @@ object CompositeViews {
  case c => IncorrectRev(c.rev, c.rev + 1)
  }
  )
+ }
 
  def apply(
  fetchContext: FetchContext,

delta/plugins/elasticsearch/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/elasticsearch/ElasticSearchViews.scala

@@ -550,14 +550,13 @@ object ElasticSearchViews {
  ElasticSearchViewCommand,
  ElasticSearchViewEvent,
  ElasticSearchViewRejection
- ] =
+ ] = {
+ val stateMachine = StateMachine(None, next)
+ val evaluator = CommandEvaluator(stateMachine, evaluate(validate, clock))
+
  ScopedEntityDefinition.untagged(
  entityType,
- StateMachine(
- None,
- evaluate(validate, clock)(_, _),
- next
- ),
+ evaluator,
  ElasticSearchViewEvent.serializer,
  ElasticSearchViewState.serializer,
  { s =>
@@ -573,4 +572,5 @@ object ElasticSearchViews {
  case c => IncorrectRev(c.rev, c.rev + 1)
  }
  )
+ }
 }

delta/plugins/storage/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/storage/files/Files.scala

@@ -726,10 +726,13 @@ object Files {
  */
  def definition(
  clock: Clock[IO]
- ): ScopedEntityDefinition[Iri, FileState, FileCommand, FileEvent, FileRejection] =
+ ): ScopedEntityDefinition[Iri, FileState, FileCommand, FileEvent, FileRejection] = {
+ val stateMachine = StateMachine(None, next)
+ val evaluator = CommandEvaluator(stateMachine, evaluate(clock))
+
  ScopedEntityDefinition(
  entityType,
- StateMachine(None, evaluate(clock)(_, _), next),
+ evaluator,
  FileEvent.serializer,
  FileState.serializer,
  Tagger[FileEvent](
@@ -752,6 +755,7 @@ object Files {
  case c => IncorrectRev(c.rev, c.rev + 1)
  }
  )
+ }
 
  /**
  * Constructs a Files instance

delta/plugins/storage/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/storage/storages/Storages.scala

@@ -460,10 +460,13 @@ object Storages {
  access: StorageAccess,
  fetchPermissions: IO[Set[Permission]],
  clock: Clock[IO]
- ): ScopedEntityDefinition[Iri, StorageState, StorageCommand, StorageEvent, StorageRejection] =
+ ): ScopedEntityDefinition[Iri, StorageState, StorageCommand, StorageEvent, StorageRejection] = {
+ val stateMachine = StateMachine(None, next)
+ val evaluator = CommandEvaluator(stateMachine, evaluate(access, fetchPermissions, config, clock))
+
  ScopedEntityDefinition.untagged(
  entityType,
- StateMachine(None, evaluate(access, fetchPermissions, config, clock)(_, _), next),
+ evaluator,
  StorageEvent.serializer,
  StorageState.serializer,
  _ => None,
@@ -473,6 +476,7 @@ object Storages {
  case c => IncorrectRev(c.rev, c.rev + 1)
  }
  )
+ }
 
  /**
  * Constructs a Storages instance