Able to perform routine task in decorator?

[Vladimir Dronnikov (dvv)]

Hello!

I have a bunch of models and interfaces like the following:

model Foo {
  @visibility(Lifecycle.Read) id: string,
  @visibility(Lifecycle.Read) slug: string,
  name: string,
  // ...
}

model Bar {
  @visibility(Lifecycle.Read) id: string,
  @visibility(Lifecycle.Read) slug: string,
  name: string,
  // ...
}

interface CRUD<Type extends Model> {
  op list(filter: FooFilter): FooRead[];
  op create(data: FooCreate): FooRead;
  op update(filter: FooFilter, data: FooUpdate): void;
  op delete(filter: FooFilter): void;
}

interface Foos extends CRUD<Foo> { ... }

interface Bars extends CRUD<Bar> { ... }

I would like to create a decorator that would routinely derive sub-models of these models:

@derive()
model Foo { ... }

// @derive is to define FooFilter, FooRead, FooCreate, FooUpdate, ...

@derive()
model Bar { ... }

// @derive is to define BarFilter, BarRead, BarCreate, BarUpdate, ...

Is there a way to do so -- by just applying a decorator to a source model?

Or one must explicitly define these models like:

// 1. define sub-model standard way
// NB: this will also create stray `ReadFoo` model
model FooRead is Read<Foo> {}

// 2. define sub-model custom way
// NB: the decorator is to mangle the copy of original
@derive()
model FooRead { ...Foo }

// 3+. any other way
// NB: it's still a ton of _routine_ defines to be entered manually

TIA