TypeScript - Passer une classe comme argument et réflexion

Question

J'écris un unmarshaller générique. Il convertit les données de base de données de graphe en classes de modèle TypeScript (1.8.7) générées. L'entrée est JSON. La sortie doit être une instance d'une classe de modèle.
Mon but ultime est de créer quelque chose comme Hibernate OGM, uniquement pour les trames Tinkerpop et TypeScript, avec le point de terminaison REST au milieu.

Quelle est la bonne façon de passer une classe en tant que paramètre et d'atteindre ses membres statiques? Je veux avoir quelque chose comme ceci:

SomeModel some = <SomeModel> unmarshaller.fromJSON({/*Object from JSON*/}, SomeModel); 

J'ai essayé d'écrire une méthode. Je ne sais pas si je me dirige dans la bonne direction, n'hésitez pas à suggérer différentes approches. Mais quand j'ai essayé d'exécuter ceci sur Plunker, j'ai eu des erreurs d'exécution avec stacktrace inutilement.

Le modèle superclasse ressemble à ceci:

/** 
* Things common to all Frames models on the Typescript side. 
*/ 
export class FrameModel 
{ 
    // Model metadata 
    static discriminator: string; 
    static graphPropertyMapping: { [key:string]:string; }; 
    static graphRelationMapping: { [key:string]:string; }; 

    // Each instance needs a vertex ID 
    private vertexId: number; 
    public getVertexId(): number { 
     return this.vertexId; 
    } 
} 

classe modèle Exemple:

import {TestPlanetModel} from './TestPlanetModel'; 
import {TestShipModel} from './TestShipModel'; 

export class TestGeneratorModel extends FrameModel 
{ 
    static discriminator: string = 'TestGenerator'; 
    static graphPropertyMapping: { [key:string]:string; } = { 
     bar: 'boo', 
     name: 'name', 
     rank: 'rank', 
    }; 
    static graphRelationMapping: { [key:string]:string; } = { 
     colonizes: 'colonizedPlanet', 
     commands: 'ship', 
    }; 

    boo: string; 
    name: string; 
    rank: string; 

    public colonizedPlanet: TestPlanetModel[]; // edge label 'colonizedPlanet' 

    public ship: TestShipModel; // edge label 'ship' 

} 

Je n'ai pas trouvé beaucoup de matériel sur la réflexion et la gestion de classe dactylographiée.
Je sais comment je ferais cela en Java.
Je sais comment je ferais cela en JavaScript.
Je comprends que je pourrais obtenir des résultats similaires avec les décorateurs, mais avoir des champs ou des champs statiques semblait un peu plus simple, pour les modèles générés.

Answer 1

Vous avez peut-être déjà remarqué que les membres de la classe ne peuvent pas avoir de mot-clé const. Mais vous pouvez aller avec static à la place. Aussi, le membre devrait être public si vous voulez qu'il soit accessible du monde extérieur.

public static graphPropertyMapping: { [key:string]:string; } = { 
    bar: 'boo', 
    name: 'name', 
    rank: 'rank', 
}; 

En ce qui concerne la création d'instance de résultat:

let result = new clazz(); 

//copy properties 

return result; 

Answer 2

Si je vous comprends bien alors voici quelque chose pour vous aider à démarrer:

interface Model {} 

interface ModelData {} 

interface MyModelConstructor<M extends Model, D extends ModelData> { 
    new(data: D): M; 
    // static members 
    graphPropertyMapping: any; 
    graphRelationMapping: any; 
} 

class Unmarshaller { 
    public fromJSON<T>(input: string | ModelData, ctor: MyModelConstructor<T, ModelData>): T { 
     let data: ModelData = (typeof input === "string") ? JSON.parse(input) : input; 

     let propertyMapping = ctor.graphPropertyMapping; 
     let relationMapping = ctor.graphRelationMapping; 

     // do whatever with the mappings 

     return new ctor(input); 
    } 
} 

(code in playground)

Je don Je ne sais pas à quoi ressemblent vos modèles, alors j'espère que c'est assez proche.

Answer 3

J'ai récemment publié une version améliorée du compilateur TypeScript qui permet exactement ce que vous attendez: lire toutes les métadonnées (statiques ou non) des champs d'une classe. Par exemple, vous pouvez écrire:

interface MyInterface { 
    active:boolean; 
    description: string; 
} 

class MyClass { 
    id: number; 
    name: string; 
    myComplexField: MyInterface; 
} 

function printMembers(clazz: Class) { 
    let fields = clazz.members.filter(m => m.type.kind !== 'function'); //exclude methods. 
    for(let field of fields) { 
     let typeName = field.type.kind; 
     if(typeName === 'class' || typeName === 'interface') { 
      typeName = (<Class | Interface>field.type).name; 
     } 
     console.log(`Field ${field.name} of ${clazz.name} has type: ${typeName}`); 
    } 
} 

printMembers(MyClass.getClass()); 

c'est la sortie:

$ node main.js 
Field id of MyClass has type: number 
Field name of MyClass has type: string 
Field myComplexField of MyClass has type: MyInterface 

Bien sûr, si vous changez vous récupérerez accès à la propriété members de clazz à statics tous les membres statiques. Ces informations peuvent également être consultées au moment du codage, de sorte que vous pouvez utiliser la saisie semi-automatique. Vous pouvez faire la même chose avec les métadonnées Interfaces. Il suffit d'écrire MyInterface par exemple, et accéder à ses membres. Vous pouvez trouver le projet here.