@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/replication-graphql/helper.ts

@@ -0,0 +1,52 @@
+import type { RxGraphQLReplicationClientState, RxGraphQLReplicationQueryBuilderResponseObject } from '../../types/index.d.ts';
+import { ensureNotFalsy, getProperty } from '../../plugins/utils/index.ts';
+
+export const GRAPHQL_REPLICATION_PLUGIN_IDENTITY_PREFIX = 'graphql';
+
+export interface GraphQLError {
+    message: string;
+    locations: Array<{
+        line: number;
+        column: number;
+    }>;
+    path: string[];
+}
+export type GraphQLErrors = Array<GraphQLError>;
+
+
+
+export function graphQLRequest(
+    fetchRequest: WindowOrWorkerGlobalScope['fetch'],
+    httpUrl: string,
+    clientState: RxGraphQLReplicationClientState,
+    queryParams: RxGraphQLReplicationQueryBuilderResponseObject
+) {
+
+    const headers = new Headers(clientState.headers || {});
+    headers.append('Content-Type', 'application/json');
+
+    const req = new Request(
+        ensureNotFalsy(httpUrl),
+        {
+            method: 'POST',
+            body: JSON.stringify(queryParams),
+            headers,
+            credentials: clientState.credentials,
+        }
+    );
+    
+    return fetchRequest(req)
+        .then((res) => res.json())
+        .then((body) => {
+            return body;
+        });
+}
+
+export function getDataFromResult(
+    result: { data: object },
+    userDefinedDataPath: string | string[] | undefined
+): any {
+    const dataPath = userDefinedDataPath || ['data', Object.keys(result.data)[0]];
+    const data: any = getProperty(result, dataPath);
+    return data;
+}

package/src/plugins/replication-graphql/index.ts

@@ -0,0 +1,255 @@
+/**
+ * this plugin adds the RxCollection.syncGraphQl()-function to rxdb
+ * you can use it to sync collections with a remote graphql endpoint.
+ */
+import {
+    ensureNotFalsy,
+    flatClone
+} from '../../plugins/utils/index.ts';
+
+import {
+    getDataFromResult,
+    graphQLRequest
+} from './helper.ts';
+
+import { RxDBLeaderElectionPlugin } from '../leader-election/index.ts';
+import type {
+    RxCollection,
+    ReplicationPullOptions,
+    ReplicationPushOptions,
+    RxReplicationWriteToMasterRow,
+    GraphQLServerUrl,
+    RxReplicationPullStreamItem,
+    RxGraphQLReplicationQueryBuilderResponseObject,
+    RxGraphQLReplicationClientState,
+    ById
+} from '../../types/index.d.ts';
+import {
+    RxReplicationState,
+    startReplicationOnLeaderShip
+} from '../replication/index.ts';
+import {
+    addRxPlugin,
+    SyncOptionsGraphQL,
+    WithDeleted
+} from '../../index.ts';
+
+import {
+    removeGraphQLWebSocketRef,
+    getGraphQLWebSocket
+} from './graphql-websocket.ts';
+import { Subject } from 'rxjs';
+
+
+export class RxGraphQLReplicationState<RxDocType, CheckpointType> extends RxReplicationState<RxDocType, CheckpointType> {
+    constructor(
+        public readonly url: GraphQLServerUrl,
+        public readonly clientState: RxGraphQLReplicationClientState,
+        public readonly replicationIdentifier: string,
+        public readonly collection: RxCollection<RxDocType, any, any, any>,
+        public readonly deletedField: string,
+        public readonly pull?: ReplicationPullOptions<RxDocType, CheckpointType>,
+        public readonly push?: ReplicationPushOptions<RxDocType>,
+        public readonly live?: boolean,
+        public retryTime?: number,
+        public autoStart?: boolean,
+        public readonly customFetch?: WindowOrWorkerGlobalScope['fetch']
+    ) {
+        super(
+            replicationIdentifier,
+            collection,
+            deletedField,
+            pull,
+            push,
+            live,
+            retryTime,
+            autoStart
+        );
+    }
+
+    setHeaders(headers: ById<string>): void {
+        this.clientState.headers = flatClone(headers);
+    }
+
+    setCredentials(credentials: RequestCredentials | undefined) {
+        this.clientState.credentials = credentials;
+    }
+
+    graphQLRequest(
+        queryParams: RxGraphQLReplicationQueryBuilderResponseObject
+    ) {
+        return graphQLRequest(
+            this.customFetch ?? fetch,
+            ensureNotFalsy(this.url.http),
+            this.clientState,
+            queryParams
+        );
+    }
+}
+
+export function replicateGraphQL<RxDocType, CheckpointType>(
+    {
+        collection,
+        url,
+        headers = {},
+        credentials,
+        deletedField = '_deleted',
+        waitForLeadership = true,
+        pull,
+        push,
+        live = true,
+        fetch: customFetch,
+        retryTime = 1000 * 5, // in ms
+        autoStart = true,
+        replicationIdentifier
+    }: SyncOptionsGraphQL<RxDocType, CheckpointType>
+): RxGraphQLReplicationState<RxDocType, CheckpointType> {
+    addRxPlugin(RxDBLeaderElectionPlugin);
+    /**
+     * We use this object to store the GraphQL client
+     * so we can later swap out the client inside of the replication handlers.
+     */
+    const mutateableClientState = {
+        headers,
+        credentials
+    };
+
+
+    const pullStream$: Subject<RxReplicationPullStreamItem<RxDocType, CheckpointType>> = new Subject();
+
+    let replicationPrimitivesPull: ReplicationPullOptions<RxDocType, CheckpointType> | undefined;
+    if (pull) {
+        const pullBatchSize = pull.batchSize ? pull.batchSize : 20;
+        replicationPrimitivesPull = {
+            async handler(
+                lastPulledCheckpoint: CheckpointType | undefined
+            ) {
+                const pullGraphQL = await pull.queryBuilder(lastPulledCheckpoint, pullBatchSize);
+                const result = await graphqlReplicationState.graphQLRequest(pullGraphQL);
+                if (result.errors) {
+                    throw result.errors;
+                }
+                let data: any = getDataFromResult(result, pull.dataPath);
+                if (pull.responseModifier) {
+                    data = await pull.responseModifier(
+                        data,
+                        'handler',
+                        lastPulledCheckpoint
+                    );
+                }
+
+                const docsData: WithDeleted<RxDocType>[] = data.documents;
+                const newCheckpoint = data.checkpoint;
+
+                return {
+                    documents: docsData,
+                    checkpoint: newCheckpoint
+                };
+            },
+            batchSize: pull.batchSize,
+            modifier: pull.modifier,
+            stream$: pullStream$.asObservable()
+        };
+    }
+    let replicationPrimitivesPush: ReplicationPushOptions<RxDocType> | undefined;
+    if (push) {
+        replicationPrimitivesPush = {
+            async handler(
+                rows: RxReplicationWriteToMasterRow<RxDocType>[]
+            ) {
+                const pushObj = await push.queryBuilder(rows);
+                const result = await graphqlReplicationState.graphQLRequest(pushObj);
+
+                if (result.errors) {
+                    throw result.errors;
+                }
+                let data: any = getDataFromResult(result, push.dataPath);
+                if (push.responseModifier) {
+                    data = await push.responseModifier(
+                        data,
+                    );
+                }
+
+                return data;
+            },
+            batchSize: push.batchSize,
+            modifier: push.modifier
+        };
+    }
+
+    const graphqlReplicationState = new RxGraphQLReplicationState(
+        url,
+        mutateableClientState,
+        replicationIdentifier,
+        collection,
+        deletedField,
+        replicationPrimitivesPull,
+        replicationPrimitivesPush,
+        live,
+        retryTime,
+        autoStart,
+        customFetch
+    );
+
+    const mustUseSocket = url.ws &&
+        pull &&
+        pull.streamQueryBuilder &&
+        live;
+
+    const startBefore = graphqlReplicationState.start.bind(graphqlReplicationState);
+    graphqlReplicationState.start = () => {
+        if (mustUseSocket) {
+            const httpHeaders = pull.includeWsHeaders ? mutateableClientState.headers : undefined;
+            const wsClient = getGraphQLWebSocket(ensureNotFalsy(url.ws), httpHeaders, pull.wsOptions);
+
+            wsClient.on('connected', () => {
+                pullStream$.next('RESYNC');
+            });
+
+            const query: any = ensureNotFalsy(pull.streamQueryBuilder)(mutateableClientState.headers);
+
+            wsClient.subscribe(
+                query,
+                {
+                    next: async (streamResponse: any) => {
+                        const firstField = Object.keys(streamResponse.data)[0];
+                        let data = streamResponse.data[firstField];
+                        if (pull.responseModifier) {
+                            data = await pull.responseModifier(
+                                data,
+                                'stream'
+                            );
+                        }
+                        pullStream$.next(data);
+                    },
+                    error: (error: any) => {
+                        pullStream$.error(error);
+                    },
+                    complete: () => {
+                        pullStream$.complete();
+                    }
+                });
+        }
+        return startBefore();
+    };
+
+    const cancelBefore = graphqlReplicationState.cancel.bind(graphqlReplicationState);
+    graphqlReplicationState.cancel = () => {
+        if (!graphqlReplicationState.isStopped()) {
+            pullStream$.complete();
+            if (mustUseSocket) {
+                removeGraphQLWebSocketRef(ensureNotFalsy(url.ws));
+            }
+        }
+        return cancelBefore();
+    };
+
+    startReplicationOnLeaderShip(waitForLeadership, graphqlReplicationState);
+    return graphqlReplicationState;
+}
+
+export * from './helper.ts';
+export * from './graphql-schema-from-rx-schema.ts';
+export * from './query-builder-from-rx-schema.ts';
+export * from './graphql-websocket.ts';
+

package/src/plugins/replication-graphql/query-builder-from-rx-schema.ts

@@ -0,0 +1,195 @@
+import {
+    GraphQLSchemaFromRxSchemaInputSingleCollection,
+    fillUpOptionals,
+    Prefixes,
+    SPACING
+} from './graphql-schema-from-rx-schema.ts';
+import { ensureNotFalsy, ucfirst } from '../../plugins/utils/index.ts';
+import type {
+    RxGraphQLReplicationPullQueryBuilder,
+    RxGraphQLReplicationPullStreamQueryBuilder,
+    RxGraphQLReplicationPushQueryBuilder,
+    RxJsonSchema,
+    TopLevelProperty,
+    WithDeleted
+} from '../../types/index.d.ts';
+
+export function pullQueryBuilderFromRxSchema(
+    collectionName: string,
+    input: GraphQLSchemaFromRxSchemaInputSingleCollection,
+): RxGraphQLReplicationPullQueryBuilder<any> {
+    input = fillUpOptionals(input);
+    const schema = input.schema
+    const prefixes: Prefixes = input.prefixes as any;
+
+    const ucCollectionName = ucfirst(collectionName);
+    const queryName = prefixes.pull + ucCollectionName;
+    const operationName = ucfirst(queryName);
+
+    const outputFields = generateGQLOutputFields({ schema, ignoreOutputKeys: input.ignoreOutputKeys })
+    // outputFields.push(input.deletedField);    
+
+    const checkpointInputName = ucCollectionName + 'Input' + prefixes.checkpoint;
+    const builder: RxGraphQLReplicationPullQueryBuilder<any> = (checkpoint: any, limit: number) => {
+        const query = 'query ' + operationName + '($checkpoint: ' + checkpointInputName + ', $limit: Int!) {\n' +
+            SPACING + SPACING + queryName + '(checkpoint: $checkpoint, limit: $limit) {\n' +
+            SPACING + SPACING + SPACING + 'documents {\n' +
+            outputFields + '\n' +
+            SPACING + SPACING + SPACING + '}\n' +
+            SPACING + SPACING + SPACING + 'checkpoint {\n' +
+            SPACING + SPACING + SPACING + SPACING + input.checkpointFields.join('\n' + SPACING + SPACING + SPACING + SPACING) + '\n' +
+            SPACING + SPACING + SPACING + '}\n' +
+            SPACING + SPACING + '}\n' +
+            '}';
+        return {
+            query,
+            operationName,
+            variables: {
+                checkpoint,
+                limit
+            }
+        };
+    };
+
+    return builder;
+}
+
+export function pullStreamBuilderFromRxSchema(
+    collectionName: string,
+    input: GraphQLSchemaFromRxSchemaInputSingleCollection,
+) {
+    input = fillUpOptionals(input);
+    const schema = input.schema;
+    const prefixes: Prefixes = input.prefixes as any;
+
+    const ucCollectionName = ucfirst(collectionName);
+    const queryName = prefixes.stream + ucCollectionName;
+    const outputFields = generateGQLOutputFields({ schema, ignoreOutputKeys: input.ignoreOutputKeys })
+
+    const headersName = ucCollectionName + 'Input' + prefixes.headers;
+
+    const query = 'subscription on' + ucfirst(ensureNotFalsy(prefixes.stream)) + '($headers: ' + headersName + ') {\n' +
+        SPACING + queryName + '(headers: $headers) {\n' +
+        SPACING + SPACING + SPACING + 'documents {\n' +
+        outputFields + '\n' +
+        SPACING + SPACING + SPACING + '}\n' +
+        SPACING + SPACING + SPACING + 'checkpoint {\n' +
+        SPACING + SPACING + SPACING + SPACING + input.checkpointFields.join('\n' + SPACING + SPACING + SPACING + SPACING) + '\n' +
+        SPACING + SPACING + SPACING + '}\n' +
+        SPACING + '}' +
+        '}';
+
+    const builder: RxGraphQLReplicationPullStreamQueryBuilder = (headers: any) => {
+        return {
+            query,
+            variables: {
+                headers
+            }
+        };
+    };
+    return builder;
+}
+
+
+export function pushQueryBuilderFromRxSchema(
+    collectionName: string,
+    input: GraphQLSchemaFromRxSchemaInputSingleCollection
+): RxGraphQLReplicationPushQueryBuilder {
+    input = fillUpOptionals(input);
+    const prefixes: Prefixes = input.prefixes as any;
+
+    const ucCollectionName = ucfirst(collectionName);
+    const queryName = prefixes.push + ucCollectionName;
+    const operationName = ucfirst(queryName);
+
+    const variableName = collectionName + prefixes.pushRow;
+    const returnFields = generateGQLOutputFields({ schema: input.schema, spaceCount: 2 })
+
+    const builder: RxGraphQLReplicationPushQueryBuilder = (pushRows) => {
+        const query = '' +
+            'mutation ' + operationName + '($' + variableName + ': [' + ucCollectionName + 'Input' + prefixes.pushRow + '!]) {\n' +
+            SPACING + queryName + '(' + variableName + ': $' + variableName + ') {\n' +
+            returnFields + '\n' +
+            SPACING + '}\n' +
+            '}';
+
+        const sendRows: typeof pushRows = [];
+        function transformPushDoc(doc: WithDeleted<any>) {
+            const sendDoc: any = {};
+            Object.entries(doc).forEach(([k, v]) => {
+                if (
+                    // skip if in ignoreInputKeys list
+                    !(input.ignoreInputKeys as string[]).includes(k) &&
+                    // only use properties that are in the schema
+                    input.schema.properties[k]
+                ) {
+                    sendDoc[k] = v;
+                }
+            });
+            return sendDoc;
+        }
+        pushRows.forEach(pushRow => {
+            const newRow: typeof pushRow = {
+                newDocumentState: transformPushDoc(pushRow.newDocumentState),
+                assumedMasterState: pushRow.assumedMasterState ? transformPushDoc(pushRow.assumedMasterState) : undefined
+            };
+            sendRows.push(newRow);
+        });
+        const variables = {
+            [variableName]: sendRows
+        };
+        return {
+            query,
+            operationName,
+            variables
+        };
+    };
+
+    return builder;
+}
+
+type GenerateGQLOutputFieldsOptions = {
+    schema: RxJsonSchema<any> | TopLevelProperty,
+    spaceCount?: number,
+    depth?: number
+    ignoreOutputKeys?: string[]
+}
+
+function generateGQLOutputFields(options: GenerateGQLOutputFieldsOptions) {
+    const { schema, spaceCount = 4, depth = 0, ignoreOutputKeys = [] } = options;
+
+    const outputFields: string[] = [];
+    const properties = schema.properties
+    const NESTED_SPACING = SPACING.repeat(depth);
+    const LINE_SPACING = SPACING.repeat(spaceCount);
+
+    for (const key in properties) {
+        //only skipping top level keys that are in ignoreOutputKeys list
+        if (ignoreOutputKeys.includes(key)) {
+            continue;
+        }
+
+        const value = properties[key];
+        if (value.type === "array" && value.items) {
+            outputFields.push(
+                LINE_SPACING + NESTED_SPACING + key + " {",
+                generateGQLOutputFields({ schema: value.items as any, spaceCount, depth: depth + 1 }),
+                LINE_SPACING + NESTED_SPACING + "}"
+            );
+        }
+        if (value.type === "object") {
+            outputFields.push(
+                LINE_SPACING + NESTED_SPACING + key + " {",
+                generateGQLOutputFields({ schema: value, spaceCount, depth: depth + 1 }),
+                LINE_SPACING + NESTED_SPACING + "}"
+            );
+        } else {
+            outputFields.push(LINE_SPACING + NESTED_SPACING + key);
+        }
+    }
+
+    return outputFields.join('\n');
+}
+
+
+