javascript - query - ¿Cómo organizar los archivos de proyecto React Native with Realm?

realm query javascript

Question

He elegido el reino para almacenar datos en mi aplicación React Native. No entiendo, cómo organizar archivos en mi proyecto. La documentación proporciona solo un código simple para un componente. Pero necesito para diferentes componentes diferentes partes de la base de datos.

Lo vi en un repositorio, donde todos los esquemas se pasaron a la matriz en el archivo "configureRealm.js":

new Realm({schema: [Dogs, Cats]});

También he descubierto que puedo poner diferentes esquemas en el directorio "esquemas", por ejemplo, e importarlos donde lo necesite.

Por ejemplo, en "Cats.js" reaccione el componente que puedo hacer:

import Cats from ''schemes/Cats'';

this.realm = new Realm({schema: [Cats]});

Y en "Dogs.js" importa perros e inicializa el reino con este esquema.

Pero no estoy seguro en primer lugar y en el mío. ¿Cuál será la mejor manera de organizar la aplicación nativa del reino?

Answer 1

En el ejemplo en el repositorio github de Realm, todos los modelos se definen y exportan desde un único archivo: https://github.com/realm/realm-js/blob/master/examples/ReactExample/components/realm.js

Entonces esto se requiere en toda la aplicación y se usa según sea necesario.

Answer 2

Hace poco comencé a organizar mi estructura de Aplicación / Datos como esta, cuando trato con Realm, después de recibir instrucciones de alguien mucho más inteligente que yo :) No entré en demasiados detalles sobre cómo se crearon inicialmente los Reinos, como supongo que son manejando eso ya. Esta es solo una estructura realmente sólida para la organización / desarrollo compartimentado. ¡Espero eso ayude!

.App
    ├──Assets
    ├──Data
    |   ├──Db
    |   |   ├──Db.js
    |   |   ├──DbHelper.js
    |   ├──Models
    |   |   ├──ModelA.js
    |   |   ├──ModelB.js
    |   |   ├──ModelC.js
    |   ├──Queries.js
    ├──Scenes
    |   ├──App.js
    |   |   ├──(all other scene/view components)

- El directorio de Modelos contiene todos mis esquemas, desglosados ​​individualmente de esta manera:

import Realm from ''realm'';
export default class ModelA extends Realm.Object {}
ModelA.schema = {
    name: ''ModelA'',
    primaryKey: ''id'',
    properties: {
        one: {type: ''int'', optional: true},
        two: ''string'',
        three: {type: ''string'', optional: true},
    }
}

- En Db.js , Db.js todos mis métodos estándar relacionados con Realm. createRealm() , write() , close() , insert() y un método de consulta genérico, como este:

query(model: string, filter?: string) {
    let results = this.realm.objects(model);
    if(filter) {
        return results.filtered(filter);
    }
    return results;
}

- DbHelper.js luego importa Db.js y todos mis modelos. Se encarga de la configuración y obtención de mi (s) instancia (s) de db, utilizando los métodos estándar de Db.js , como este:

import Db from ''App/Data/Db/Db'';
import ModelA from ''App/Data/Models/ModelA'';
import ModelB from ''App/Data/Models/ModelB'';
import ModelC from ''App/Data/Models/ModelC'';

class DbHelper {

    modelSchema = [
        ModelA,
        ModelB,
        ModelC
    ];

    activeInstancePath = (myLocalRealmPath)

    getInstance(): Db {
        let instance: Db = this.activeInstancePath;
        if(!instance) {
            throw new Error(''DbHelper.js :: Active Instance Not Set!'');
        }
        return instance;
    }

    /* note: this is where you would also setInstance and define a constant, or other method for the instance path */
}

- Queries.js luego importa DbHelper.js . Queries.js contiene todos mis métodos para consultas de datos relacionadas con aplicaciones específicas. Queries.js es todo lo que necesito para importar a mis componentes de Scene para obtener datos de Realm. Mis Queries.js ve algo como esto:

import DbHelper from ''App/Data/Db/DbHelper'';

class Queries {

    /* a typical query */
    getSomeDataFromModelA(filterValue: string = null) {
        let filter = null;
        if (filterValue) {
            filter = `two = ${filterValue}`;
        }
        let results = DbHelper.getInstance()
            .query(''ModelA'', filter);

        return results;
    }

    /* return some JSON data that we originally stored in the Realm as a string */
    getSomeJsonData() {
        let results = DbHelper.getInstance()
            .query(''ModelB'');

        if(results.length) {
            let parsed = JSON.parse(results[0].objectA);
            return parsed.objectB;
        }
        return null;
    }
}
export default new Queries();

--App.js. Así que ahora, en mi App Scene, simplemente haría algo como esto:

import React, { Component } from ''react'';
import { View, Text } from ''react-native'';
import Queries from ''App/Data/Queries'';

class App extends Component {

    constructor(props) {
        super(props);

        // Get Some Realm Data!
        let modelAData = Queries.getSomeDataFromModelA()
        let someJsonData = Queries.getSomeJsonData();

        // Set Initial state
        this.state = {
            modelData: modelAData,
            jsonData: someJsonData
        }
    }

    componentDidMount() {
        console.log(this.state.modelData);
    }

    render() {
        return(
            <View>
                <Text>{this.state.jsonData.objectKey}</Text>
            </View>
        );
    }
}

export default App;