Index signature for type 'string' is missing in type...

[dallenbaldwin]

Hi!

I recently discovered Typescript mixins and saw a lot of potential with my entity schema because it enables me to compose my classes. I got really excited because it seems to work just fine with typeorm and type-graphql. Composition is much more preferable to simple inheritance because of annoying decisions made at the database level I have no control over.

However... it seems these mixins break the Resolver Interface utility interface. I'm getting the error Index signature for type 'string' is missing in type <object type> when trying to use the resolver interface with any of these composed classes.

I don't know enough about Typescript to fix it or come up with a similar workaround and was wondering if anyone else has run into it and have a solution.

Here's some code for anyone who want's to reproduce it. I'm using the Active Record pattern with typeorm

// absolute base class
@ObjectType({ isAbstract })
export class DBOEntity extends BaseEntity {
  /**
   * a GUID used to globally identify this record in the database
   */
  @Field({
    description: 'a GUID used to globally identify this record in the database',
  })
  @PrimaryColumn({ name: 'GlobalID' })
  globalId!: string

  ...
}

// a "soft-deletable" entity
// most things are deletable, but not all
export function Deletable<T extends ClassType>(t: T) {
  @ObjectType({ isAbstract })
  class Deletable extends t {
    /**
     * a `FindOperator` to only include soft deleted records
     */
    static isDeleted = yesNo(WorseBoolean.YES)
    /**
     * a `FindOperator` to exclude soft deleted records
     */
    static notDeleted = yesNo(WorseBoolean.NO)
    /**
     * only includes deleted records
     * @param entities a list of entities to filter out un-deleted records
     */
    static async allDeleted<T extends Deletable>(deletables: T[]) {
      return filterWorseBoolean(deletables, 'deleted', WorseBoolean.YES)
    }
    /**
     * excludes deleted records
     * @param entities a list of entities to filter out deleted records
     */
    static noneDeleted<T extends Deletable>(deletables: T[]) {
      return filterWorseBoolean(deletables, 'deleted', WorseBoolean.NO)
    }

    /**
     * an enum describing the soft-delete status of the record
     *
     * possible values: `Yes`, `No`, or undefined
     */
    @Field(() => YesNoScalar, {
      nullable,
      description: enumValues({
        describing: 'the soft-delete status of the record',
        items: WorseBooleans,
      }),
    })
    @Column({ nullable, name: 'Deleted' })
    deleted?: WorseBoolean
  }
  return Deletable
}

// some entities are also achivable
export function Archivable<T extends ClassType>(t: T) {
  @ObjectType({ isAbstract })
  class Archivable extends t {
    /**
     * a `FindOperator` to only include archived records
     */
    static isArchived = yesNo(WorseBoolean.YES)
    /**
     * a `FindOperator` exclude archived records
     */
    static notArchived = yesNo(WorseBoolean.NO)
    /**
     * only includes archived records
     * @param archivables
     */
    static allArchived<T extends Archivable>(archivables: T[]) {
      return filterWorseBoolean(archivables, 'archived', WorseBoolean.YES)
    }
    /**
     * excludes archived records
     * @param archivables
     */
    static noneArchived<T extends Archivable>(archivables: T[]) {
      return filterWorseBoolean(archivables, 'archived', WorseBoolean.NO)
    }

    /**
     * the date this record was archived in the database
     */
    @Field({ nullable, description: dateField('archived in') })
    @Column({ name: 'Archive_Date', nullable })
    archiveDate?: Date

    /**
     * the username or email address of a mobile app user associated with the `archiveDate`
     */
    @Field({ nullable, description: userField('archiveDate') })
    @Column({ name: 'Archive_User', nullable })
    archiveUser?: string

    /**
     * an enum describing the archive status of the record
     *
     * possible values: `Yes`, `No`, or null
     */
    @Field(() => YesNoScalar, {
      nullable,
      description: enumValues({
        describing: 'the archive status of the record',
        items: WorseBooleans,
      }),
    })
    @Column({ name: 'Archived', nullable })
    archived?: WorseBoolean
  }
  return Archivable
}

Now here's the usage. It's also entirely possible I'm not using class mixins correctly... in which case... please correct me

// entity + object type
@ObjectType()
@Entity({ name: 'PROJECTS' })
export class Project extends Archivable(Deletable(DBOEntity)) {
  @Field({ nullable })
  @Column({ name: 'Project_Name', nullable })
  projectName?: string

  ...
}

// from type-grapqhl
type ResolverInterface<T extends object> = {
  [P in keyof T]?: (root: T, ...args: any[]) => T[P] | Promise<T[P]>
}

// Class 'ProjectResolver' incorrectly implements interface 'ResolverInterface<Project>'.
//   Index signature for type 'string' is missing in type 'ProjectResolver'. ts(2420)
@Resolver(Project)
export class ProjectResolver implements ResolverInterface<Project> {
   ...
}

[MichalLytek]

I guess ResolverInterface works only for simple cases. You're not obliged to use it, use can write your own type helper to make sure field resolvers signature matches fields type.

[dallenbaldwin]

Do you have any suggestions on how/where to start building my own type that would "do the same thing"? I really like the safety it provides