Typescript - can't access properties in child class via Object.keys()

I am trying to use the same logic declared in constructor of base class for all child classes.
In more details, I want to iterate over all class attributes from it's constructor.

My expectation was that if I invoke Object.keys() in base constructor and call super() in child's constructor - it will work for me.

Code example:

class BaseClass {
    private baseField1: string;
    private baseField2: string;

    constructor(data: any) {
        console.log(this.constructor.name + " has fields: " + Object.keys(this));
    }
}

class ChildClass extends BaseClass {
    private childField1: string;

    constructor(data: any) {
        super(data);
    }
}

let base = new ChildClass({name: 'Joe'});

I expect to have output:
ChildClass has fields: baseField1,baseField2,childField1

But in fact I have:
ChildClass has fields: baseField1,baseField2

There is no childField1 in output

Any idea on how this is better to sort out?

UPD:

Finally I made it work as I expect. Thanks to Touffy!

class BaseClass {
    private baseField1: string;
    private baseField2: string;

    constructor(data: any) {
        Object.assign(this, data);
    }
}

class ChildClass extends BaseClass {
    private childField1: string;

    constructor(data: any) {
        super(data);
        if (data.childField1) this.childField1 = data.childField1;
    }
}

let base = new ChildClass({
    baseField1: 'bf1',
    baseFileds2: 'bf2', 
    childField1: 'Joe'
});

console.log('Class fields: ' + JSON.stringify(base));

Output is: Class fields: {"baseField1":"bf1","baseFileds2":"bf2","childField1":"Joe"}

The issue is not with Object.keys, but the timing of when it is called in the constructor chain. You wrote the call of Object.keys in the parent constructor, which is called by super in the child constructor before any child properties are initialized.

You need to remember that those nice property declarations are merely syntactic sugar, equivalent to this.propertyName = undefined in the constructor. Those lines are evaluated after the call to super (the parent constructor). In other words, what the JavaScript interpreter will really do is this :

class BaseClass {
    constructor(data) {
        this.baseField1 = undefined;
        this.baseField2 = undefined
        console.log(this.constructor.name + " has fields: " + Object.keys(this));
    }
}

class ChildClass extends BaseClass {
    constructor(data) {
        BaseClass.call(this, data);
        this.childField1 = undefined // too late !
    }
}

If you call Object.keys in the child constructor after super(), or anywhere that's not in a constructor, it will work as expected.

However, if your goal is specifically to log all the properties of a child instance immediately when it is constructed, and have this behaviour inherited from the parent class… I don't think you can, even with Proxies.

constructor(data: any) -- this is not OOP, this is bad JavaScript habits under disguise.

Be as specific as possible with the interface of your class. Let it ask exactly what values it needs in the constructor, not just some opaque object.

class BaseClass {
  public constructor(
    private baseField1: string,
    private baseField2: string,
  ) {
    // Object.keys(this) is not a good idea if the class has methods
    console.log(this.constructor.name + " has fields: " + Object.keys(this));
  }
}

class ChildClass extends BaseClass {
  public constructor(
    baseField1: string,
    baseField2: string,
    private childField1: string;
  ){
    super(baseField1, baseField2);
  }
}

// The compiler does not allow you to pass only one argument to the constructor
// It ensures the object integrity
let base = new ChildClass('Joe');