[ES6] Wie Klassenobjekt Proxifizieren vor Kontruktoraufruf

[DPA (Gast)]

Ich habe die (vielleicht etwas verrückte) Idee nun schon seit ein paar 
Jahren, aber ich kann einfach keine Lösung dafür finden.

Es geht darum, mittels eines Proxy Objekts sämtliche Zugriffe eines 
Objekts, inklusive die durch den Konstruktor, welcher dieses 
initialisiert, abzufangen.

Mit altmodischen Funktionen war das relativ einfach, dort konnte man 
einfach call oder apply benutzen, aber bei ES6 Klassen geht das nicht 
mehr:

function A(){
  this.test = 123;
}

class B {
  constructor(){
    this.test = 123;
  }
}

// statt "new T(...args)", manuell das selbe tun, aber Proxy darum legen
function proxify(T, ...args){
  let proxy = new Proxy(Object.create(T.prototype), {
    set(that, prop, value){
      console.log(prop, value);
      that.prop = value;
    }
  });
  T.call(proxy, ...args);
  return proxy;
}

let a = proxify(A); // Ausgabe: test 123
let b = proxify(B); // Fehler: Uncaught TypeError: Class constructor B cannot be invoked without 'new'

In ES6 wurde apply mit Konstruktoren verboten, damit man nicht 
versehentlich mit A() globale Variablen erstellt usw.

Meine nächste Idee war, die constructor prototype chain zu hijacken:

function proxify($class, interceptor, ...args){
  if(!$class || !($class instanceof Function))
    throw new TypeError("$class must be a class or function");
  let topproto = $class, next=Object.getPrototypeOf(topproto);
  if(!next || !(next instanceof Function))
    throw new TypeError("Unsupported prototype chain");
  while(next instanceof Function){
    topproto = next;
    next = Object.getPrototypeOf(next);
  }
  console.log(topproto, next);
  Object.setPrototypeOf(topproto, interceptor);
  let error = null;
  try {
    var result = new $class(...args);
  } catch(e) { error = e; }
  Object.setPrototypeOf(topproto, next);
  if(error)
    throw error;
  return result;
}

let x = proxify(B, function(){
  return new Proxy(this, {
    set(that, prop, value){
      console.log(prop, value);
      that.prop = value;
    }
  });
});

Funktioniert aber leider nicht. Bei A extends B extends C könnte ich vor 
C und vor B eingreifen und das Objekt in einen Proxy einbetten, aber 
nicht nach C, weil die oberste klasse anscheinend den super Construktor 
nicht aufruft...

Dann hab ich es über den Prototype versucht:

B.prototype = new Proxy(this, {
  set(that, prop, value){
    console.log(prop, value);
    that.prop = value;
  }
});
(new B()).test = 123;

War leider auch nichts.

Hat sonst noch jemand eine Idee, wie man das eventuell doch noch 
hinkriegen könnte?

[DPA (Gast)]

Ich habe zwar keine echte Lösung für das Problem gefunden, aber ein 
Workaround:

class A {
  init(){}
};

function f(){
  this.init();
}
f.prototype = A.prototype;
let o = new f();

Apply geht nur beim constructor nicht, bei einer anderen Methode, hier 
init, aber schon. Mit der Funktion f als abgeleitete Klasse muss ich den 
Konstruktor nicht aufrufen, und kann diesen damit "unschädlich" machen. 
Dann initialisiere ich das einfach in einer init Methode. Und vor deren 
Aufruf kann ich dort den this parameter bequem in einen Proxy verpacken. 
Nicht perfekt, aber ein brauchbarere Workaround. Als bonus kann ich init 
sogar async machen, noch was, was mit einem constructor nicht ginge!