Add new hooks in the replication write

[jonathan-neugber]

This PR contains:

• Two new hooks

Describe the problem you have without this PR

We'd like to have local fields in a row that are not replicated to the server.
These hooks allow us to modify the replication a bit to filter out rows that do not need to be replicated or need to be updated after replication to include the local fields again.

I'm just not really sure how to best write unit tests for this but help/feedback would be greatly appreciated

An example plugin I wrote to handle this:

import {RxCollection, RxDocType, RxPlugin, RxReplicationWriteToMasterRow, WithDeleted} from "rxdb/src/types";
import {deepEqual} from "rxdb";

let rowsToUpdatePerSchema = {};

export const LocalFieldsPlugin: RxPlugin = {
    name: 'LocalFields',
    rxdb: true,
    hooks: {
        preReplicationMasterWrite: {
            after: async ({rows, collection}: {rows: RxReplicationWriteToMasterRow<RxDocType>[], collection: RxCollection<RxDocType>})  => {
                const name = collection.name;
                const localFields = collection.schema.jsonSchema.local || [];

                if (localFields.lenght === 0) {
                    return;
                }

                const rowsToUpdate = {};

                const filtered = rows.filter((row) => {
                    let localFieldChanged = false;
                    let serverFieldChanged = false;

                    const localChanges = {};

                    for (const [key, value] of Object.entries(row.newDocumentState)) {
                        const masterValue = row.assumedMasterState[key] ?? null;

                        if (deepEqual(value, masterValue)) {
                            continue;
                        }

                        if (localFields.includes(key)) {
                            localChanges[key] = value;
                            localFieldChanged = true;
                            delete row.newDocumentState[key];

                            continue;
                        }

                        serverFieldChanged = true;
                    }

                    if (localFieldChanged === true && serverFieldChanged === false) {
                        return false;
                    } else if (localFieldChanged) {
                        rowsToUpdate[row.newDocumentState.id] = localChanges;
                    }

                    return true;
                });

                rowsToUpdatePerSchema[name] = rowsToUpdate;

                rows.splice(0, rows.length);
                rows.push(...filtered);
            }
        },
        preReplicationMasterWriteDocumentsHandle: {
            after: async ({result, collection}: {result: WithDeleted<RxDocType>[], collection: RxCollection<RxDocType>}) => {
                const localFields = collection.schema.jsonSchema.local || [];

                if (localFields.lenght === 0) {
                    return;
                }

                const name = collection.name;

                const rowsToUpdate = rowsToUpdatePerSchema[name];

                if (!rowsToUpdate) {
                    return;
                }

                const mapped = result.map((row) => {
                    const updateData = rowsToUpdate[row.id];

                    if (!updateData) {
                        return row;
                    }

                    return {
                        ...row,
                        ...updateData,
                    }
                });

                result.splice(0, result.length);
                result.push(...mapped);
            }
        }
    }
};

Todos

• Tests
• Documentation

[pubkey]

Code looks good. But the CI fails, please check.

[jonathan-neugber]

Turns out my local machine had some configuration problems in which eslint didn't correctly work. Now it should finally pass 😅

[pubkey]

Great, merged.