Développer un ORM offline/fullstack

a marqué ce sujet comme résolu.

Bonjour à toutes et tous,

Mes meilleurs vœux pour cette année 2019.

Je voulais réaliser un projet mais je n’ai pas trouvé les outils me permettant de réaliser ce projet comme je le souhaitais, du coup je réfléchit à créer cet outil.

L’origine du problème vient de l’objectif offline first, je souhaite réaliser une application capable de fonctionner même en cas de coupure de réseau, et ce, de manière transparente dans le code.

En creusant le sujet je me suis rendu compte que cela soulevais une série de problème, la difficulté majeure étant la validation des données. Comment s’assurer que les données modifiée sur le client sont correct ? Le seul élément dont on peut garantir l’intégrité c’est le serveur, lui seul est apte à réellement appliquer une modification sur les données.

L’idée est donc la suivante: avoir une base de données partielle sur le client, lorsque celui-ci réalise une modification dans son application elle est réalisée sur sa base de données cliente et enregistrée dans une base système. Lors de la connexion du client au serveur le serveur rejoue la fonction de façon à ce que les données soient réellement modifiée.

L’outil se concentre donc sur la gestion des données, un outil très pratique lorsque l’on manipule des données est l’utilisation d’un ORM aussi je souhaite qu’il se présente comme tel.

Voici comment dans l’idéal je souhaiterai que l’on puisse l’utiliser.

/*
 * Composant client
 */

@Component()
export class UserComponent {
    constructor(private userMiddle: UserMiddle) {}
    
    updateUser(User user) {
        userMiddle.update(user);
    }
}

/*
 * Entité
 * Basé sur TypeORM
 */

@Entity()
export class User {
    @Column()
    firstname: string;
    
    @Column()
    lastname: string;
    
    @ManyToOne(type => User)
    dad: User;
}

/*
 * Classe middleware étant disponible sur le client et sur le serveur
 * Destinée à manipuler les données
 */

@Middle()
export class UserMiddle {
    constructor(private userRepository: UserRepository, 
        private notifRepository: NotifRepository
        private userServer: UserServer) {}
    
    update(User user) {
        userRepository.save(user);

        const notif = new Notification(); // Notification est également une Entity
        notif.user = user;

        notifRepository.save(notif);
        userServer.sendMail();
    }
}

@Server()
export class UserServer {
    
    sendMail() {
        // envoyer le mail
    }
}

Il reste néanmoins encore des difficultés, par exemple l’idéal aurai été que le middleware n’aie pas à faire appel aux fonctions serveur car comment ne pas planter coté client lorsque l’on fera appel à ces fonctions inexistante ? Comment gérer les erreurs ? Si le mail ne par pas, comment le serveur va remonté l’information jusqu’au client (qui à peut-être réalisé cette action il y à plusieurs heures).

Sans compter que des données peuvent être privée, pour un utilisateur on peu imaginer stocker son adresse ip, seul les administrateur peuvent y avoir accès. Il faut donc introduire la notion de rôle au niveau même des Entity alors que cela devrai être du ressors du contrôleur, surtout que cela dépens du contexte, on pourrai imaginer des cas où l’on puisse accéder à une donnée privée si l’on répond à une charade (donc non basé sur les rôles). C’est réalisable, néanmoins se pose la question: est-ce la bonne façon de faire ?

J’aurai aimé pouvoir créer un outil parfait, cependant je ne pense pas que cela soie possible, nombre d’outils existe déjà et ne sont pas parfait et ne réponde pas à tout. Par exemple, je souhaite utiliser comme technologie sous-jacente PouchDB pour le stockage et la réplication des données. Eux-même ne résolve pas ce genre de problème.

En réalité je suis plutôt surpris qu’il n’existe pas déjà des outils répondant à la problématique, il existe déjà des outils pour à peu près tout, mais finalement si peu qui s’occupe de la gestion des données offline autrement que du bas niveau.

Bref, c’est un projet dans lequel je souhaite me lancer. J’aurai cependant besoin d’un œil critique. L’idéal serai même quelqu’un qui souhaite se lancer dans le projet avec moi, mais je ne crois pas que cela arrivera.

Merci d’avance pour vos retours.

+0 -0

Bonjour,

Le principe de résilience est relativement commun en programmation. Notamment Meteor utilise une base MongoDb like pour stocker côté client les données qui ne sont pas encore transférés et ainsi optimiser l’accès à celles dont il a besoin dans l’immédiat.

Ensuite pour assurer la cohérence des données, rien de mieux qu’un fichier de journalisation : date/heures + opération + données. A l’étape de synchronisation, on valide les entrées pour reconstruire la BDD finale. Certains ordres d’opérations seront modifiés pour s’adapter.

Au niveau des données sensibles et restrictions, il est tout à fait envisageable de choisir un chiffrement de bout-en-bout ; le mot de passe protège un portefeuille de clé qui donne accès à certaines données. Je sais qu’il existe des méthodes pour obtenir une clé de réinitialisation en cas de perte du mot de passe "maître" (à voir de ton côté).

A part te donner un mille-feuille d’idées … je peux t’affirmer une chose : des solutions parfaites en la matière ça n’existe pas. Y’aura toujours un compromis. Des données qui ne passeront pas correctement ou un choix délibéré de prendre une modification plutôt qu’une autre (par exemple préférer ajouter plutôt que supprimer ou corriger l’erreur plutôt que planter l’application).

J’imagine que ton code source c’est du Angular ; c’est déjà à mon avis un bon choix de technologie que de choisir un framework JS (React, Vue.js, Meteor, Ember.js etc). Bon courage !

Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte