multi-dimentional layers

[craigmulligan]

We are using layers to enforce a typical application hierarchy e.g.: ['feature', 'service', 'repo'], which is working well.

But we second similar dimension we'd like to enforce. Let's call it stable and experimental. Where experimental modules can depend on stable modules but not the other way around - this could be enforce by layers.

WDYT about supporting multiple layers?

# tach.toml
[layers.app]
layers = [
  "feature",
  { name = "service", closed = true },
  "repo"
]

[layers.stability]
layers = [
  "stable",
  "experimental"
]

# tach.domain.toml
[layer]
type = "app"
layer = "service"

[layer]
type = "stability"
layer = "experimental"

[DetachHead]

if i understand this correctly, what you're asking for is dimensions of layers, where a module needs to be in a higher layer than a module it's importing in every dimension?

if so, i don't really understand how that proposed configuration works. what about something like this (taken from this example in the docs):

layers = [
    [
      "ui",
      "commands",
      "core"
    ],
    [
      "stable",
      "experimental"
    ],
]

[[modules]]
path = "tach.check"
layer = ["commands", "stable"]

[[modules]]
path = "tach.cache"
depends_on = ["tach.filesystem"]
layer = ["core", "experimental"]

[[modules]]
path = "tach.filesystem"
depends_on = []
layer = ["core", "experimental"]

it sounds like an interesting idea but i'm curious as to what use cases there are for this. i feel like it may be overcomplicating a feature that's intended to be a simpler alternative to just using depends_on

[craigmulligan]

if i understand this correctly, what you're asking for is dimensions of layers, where a module needs to be in a higher layer than a module it's importing in every dimension?

yes that's correct.

if so, i don't really understand how that proposed configuration works. what about something like this (taken from this example in the docs):

Yeah this config would work 👍

it sounds like an interesting idea but i'm curious as to what use cases there are for this. i feel like it may be overcomplicating a feature that's intended to be a simpler alternative to just using depends_on

We have the classic Presentation - Business Logic - Data we'd like to enforce, on top of that we also have "experimental" and "stable" parts of the codebase.

We treat experimental code differently in that there maybe less requirements for testing, they also may get deployed with less resources etc.

We'd like to make sure that there are no dependencies from stable -> experimental modules.

We could ofc make sure all "experimental" modules are very strict with which resources can use their interfaces, but ideally there would be an automated check to prevent this - "layers" feels like a natural fit.

[DetachHead]

i see, thanks for elaborating