Typescript - Extending class with type

Question

Typescript newbie here. Let's say I have a type coming from a library that looks like this:

type FooType {
  name: string;
  // Has much more attributes in real life
}

I now want to define a class called Foo like this:

import { FooType } from 'my-library';

class Foo {
  constructor(data: FooType) {
    Object.assign(this, data);
  }
}

With this code, I'm able to define a foo instance, yet I have an issue with autocomplete:

const foo = new Foo({ name: 'foo name' });
// Typing in foo.name does not bring any type information about the "name" attribute

Is there a way I can make a class automatically "inherit" all attributes from a type without having to type them manually?

Edit after being marked as duplicate:

What I want to achieve is to avoid manually typing attributes that are already existing on a type.

Thanks to @Phil I've been provided an answer that mentions this as an ongoing issue within Typescript: https://github.com/microsoft/TypeScript/issues/26792

What I will do for now is the following:

class Foo {
  constructor(public _data: FooType)
    Object.assign(this, _data);
  }

  get() {
    return this._data;
  }
}

const foo = new Foo({ name: 'Bar' });
foo.get().name; // After typing "foo.get()" the autocomplete works properly.

Answer 1

Note: this is just a workaround and doesn't fix the underlying issue with using Object.assign() in the constructor with TypeScript.

https://github.com/Microsoft/TypeScript/issues/16672

Update: this question definitely lead me down quite the rabbit and I wasn't quite happy with my previous response so here is something I think would work better for solving these two items:

• Creating a class which extends an object
• Allowing TypeScript to still do its thing

Step One: use the typescript mixin pattern to return an anonymous class with the properties of a generic object T:

function GenericBase<T>(data: T) {
  return class {
    constructor() {
      Object.assign(this, data)
    }
  } as ({
      new (...args: any[]): T;
  })
}

Now we have an anonymous function with a constructor which is then casted as a class that returns our generic object T.

Step Two: Note that we don't need to touch the above code we just need to extend it, so for OP's example we would do this:

class MyClass extends GenericBase(foo) {

  constructor() {
    super()
  }

  greet() {
     return `Hello, ${this.name}!`
  }
}

More examples:

const myClass = new MyClass()
console.log(myClass.name)       // bar
console.log(myClass.greet())    // Hello, bar!


function doSomethingWithFoo(someFoo: Foo) {
  // example method that only takes types Foo
}

doSomethingWithFoo(myClass)

Try it on the TypeScript playground!