✨ [Typescript] eslint rule to avoid some common gotchas

[Xiot]

What are you trying to do?

While trying to get around #7401, I tried to keep the @field as a string, but then just type a custom property.

@object()
export class MergeRequestReference {
  @field() _iid: string
  @field() _type: string

  constructor(iid: string, type: 'head' | 'merge') {
    this._iid = iid
    this._type = type
  }

  get iid() {
    return this._iid
  }
  get type() {
    return this._type
  }
}

However it seems that the prototype isn't actually preserved when the object is used from another module.

First prize, would be to re-attach the prototype chain, but barring that, it would be nice to have an eslint rule to catch things that work slightly differently than a typescript developer would expect.

Why is this important to you?

It would avoid some errors caused by the way that dagger modules are executed.

How are you currently working around this?

I just removed the custom getters, and I check the types later in the code

[TomChv]

@Xiot Thanks for your report!

However it seems that the prototype isn't actually preserved when the object is used from another module.

It's because we currently do not support that kind of annotation (see #7401 (comment))

First prize, would be to re-attach the prototype chain, but barring that, it would be nice to have an eslint rule to catch things that work slightly differently than a typescript developer would expect.

I'm not sure I understand the idea behind, do you mean having an eslint that can catch unsupported feature of the SDK such as custom inline union type?

[Xiot]

Well there two main things here. Well 3 if you count the string literals, but thats for another issue.

The thing that caught me a little off guard was that the prototype chain isn't preserved when you re-hydrate a field.

@object()
class RootModule {
  @func() test() {
    return new PModule(new PCheck(4))
  }
}

@object()
class PCheck {
  @field() value: number

  constructor(value: number) {
    this.value = value
  }
  get doubled() {
    return this.value * 2
  }
}

@object()
class PModule {
  @field() value: PCheck
  constructor(value: PCheck) {
    this.value = value
  }
  @func() print() {
    console.log('value', this.value, Object.getPrototypeOf(this.value))
    return this.value.doubled ?? 0
  }
}

Calling

dagger call test print

will return 0 and will print

value { value: 4 } [Object: null prototype] {} 

That shows that prototype of the value field is set to null, so the doubled property isn't actually there.

My comment about eslint, was coming up with a way to let developers know that even though what they are doing is supported in the language, it won't actually work.

[Xiot]

I should have actually created a bug for the prototype not being there, rather than the eslint rule

[Xiot]

Created a separate issue for the prototype #7446