Datenladungsmuster für KnockoutJs

Question

Ich versuche zu verstehen, ob Knockoutjs für meine Bewerbung funktionieren wird. Mein Datenmodell (vereinfacht) ist wie folgt:

function topic(data) {
    this.id = data.id;
    this.queries = ko.observableArray([]);
}

function query(data) {
    this.id = data.id;
    this.text = data.text;
    this.searcher = data.searcherId;
    this.postings = ko.observableArray([]);
}

function posting(data, query) {
    this.documentId = data.docid;
    this.rank = data.rank;
    this.snippet = data.snippet;
    this.score = data.score;
    this.query = query;
    this.document = null;
}

function document(data, topic) {
    this.id = data.id;
    this.url = data.url;
    this.topic = topic;
}

Für ein gegebenes topic, Ich habe einen oder mehrere query Instanzen. Jede Abfrage enthält eine Liste von posting Instanzen. Jeder posting bezieht sich auf ein Dokument. Mehr als eine posting kann sich auf eine gegebene beziehen document solange die posting Instanzen gehören zu anderen query Instanzen.

Wenn ein posting bezieht sich auf ein neues Dokument (eines, das noch nicht von einem abgerufen wurde query) Ich möchte eine neue Instanz erstellen; Wenn die document Es gibt bereits (IDs sind einzigartig), ich möchte es wiederverwenden.

Ich kann einige mögliche Alternativen zum Strukturieren der vom Server zurückgegebenen JSON -Daten sehen:

1. Bei der Serialisierung von Beiträgen serialisieren Sie zunächst eine Liste aller Dokumente und aktualisieren Sie die Master -Dokumentliste mit ihnen. Senden Sie dann Beiträge mit Referenzen an Dokument -IDs.
2. Serialisieren Sie jedes Dokument vollständig als Eigenschaft eines Beitrags und finden Sie dann heraus, ob dieser Eintrag überflüssig ist. Fügen Sie der Master-Liste nicht redundante Einträge hinzu.

Was ist ein vernünftiges Muster für die Serialisierung der Daten? Gibt es einige Mapping -Plugin -Magie, die so prägnant ausdrücken würden? Ich habe die Kontrolle über den Server, der den JSON generiert, und kann das in jeder Hinsicht strukturieren.

Vielen Dank,

Gen

Answer 1

Hier ist, was ich getan habe, um Option 1 zu implementieren:

function idField(data) {
    return ko.utils.unwrapObservable(data.id);
}

function createMapping(type, context) {
    return {
        key:    idField,
        create: constructor(type, context)
    }
}

function constructor(type, context) {
    return function(options) { 
        return new type(options.data, context); 
    }
}

function createReferenceMapping(collection) {
    return {
        key: idField,
        create: lookup(collection)
    }
}

function lookup(collectionOrClosure) {
    return function(options) {
        var collection = (typeof collectionOrClosure == 'function') ? collectionOrClosure() : collectionOrClosure;

        var object = collection.findById(options.data.idref);
        if (object == null)
            console.log("Error: Could not find object with id " + options.data.idref + " in ", collection);
        return object;
    }
}

Ich nenne diesen Code wie folgt:

    var mapping = {
        people: createMapping(Searcher),
        topics: createMapping(Topic, this),
        activeTopic: createReferenceMapping(function(){return self.topics();})
    };

    this.dataChannel.loadModel(function(data) {
        ko.mapping.fromJS(data, mapping, this);
    }

Dies achtet beide darauf, neue Instanzen zu erstellen (über die constructor Funktion) und vorhandene überblicken lookup.

Answer 2

Checkout entitySpaces.js, es gibt ein Video, das Sie sehen können. Es unterstützt vollständige Hierarchcial -Datenmodelle und generiert sogar Ihren WCF JSON -Dienst. Es unterstützt auch REST -APIs.

Ein JavaScript -ORM -Framework (Data Access), das Knockout verwendet

https://github.com/entityspaces/entityspaces.js#readme