Combining decorators

[eddyashton]

Is there any way to combine (or otherwise define/extend/alias) decorators, so that a combination of decorators can be repeatedly applied?

My use case is that I have a lot of ID fields which are hex, and exactly 64 characters long, in various models.

model User {
  @key
  @format("hex")
  @pattern("^[a-f0-9]{64}$")
  userId: string;
}

model Member {
  @key
  @format("hex")
  @pattern("^[a-f0-9]{64}$")
  memberId: string;
}

model Proposal {
  @key
  @format("hex")
  @pattern("^[a-f0-9]{64}$")
  proposalId: string;
}

I'm looking for a way to reduce the repetition here, and ideally apply a single decorator to each instance (or extend some base model but change the field name, or...). I can use alias idRegex = "^[a-f0-9]{64}$" to avoid repeating the regex itself, but I can't work out how to combine the decorators themselves. It appears they are syntactically special, and so I think it's not possible to use them in a template or type intersection to get the desired result?

[NielsCo]

You can use a custom scalar that then will be referenced. Like this:

@format("hex")
@pattern("^[a-f0-9]{64}$")
scalar MyScalar extends string;

model User {
  @key
  userId: MyScalar;
}

model Member {
  @key
  memberId: MyScalar;
}

model Proposal {
  @key
  proposalId: MyScalar;
}

But be aware that it will be referenced in the openAPI output. Like this:

components:
  schemas:
    Member:
      type: object
      properties:
        memberId:
          $ref: '#/components/schemas/MyScalar'
      required:
        - memberId
    MyScalar:
      type: string
      format: hex
      pattern: ^[a-f0-9]{64}$
    Proposal:
      type: object
      properties:
        proposalId:
          $ref: '#/components/schemas/MyScalar'
      required:
        - proposalId
    User:
      type: object
      properties:
        userId:
          $ref: '#/components/schemas/MyScalar'
      required:
        - userId

As @key is set on a ModelProperty and not on a Scalar you still need to set it on every model-property. But I think just as defining a custom type in another language this is by design (as having custom data-types that set something on the object-level would be weird I think.)

You could also think about using the spread operator or inheritance (if you don't mind the id-name being not adjustable).

model KeyModel {
  @format("hex")
  @pattern("^[a-f0-9]{64}$")
  @key 
  id: string
}

model User {
 ...KeyModel
}

model Member {
  ...KeyModel
}

model Proposal {
  ...KeyModel
}