feat: added code for replication config

Author: biozal

expo-example/app/replication/config.tsx

@@ -1,18 +1,22 @@
-import React, { useState } from 'react';
+import React, { useContext, useState } from 'react';
 import { Database } from 'cbl-reactnative';
 import { SafeAreaView, ScrollView, StyleSheet } from 'react-native';
 import { useStyleScheme } from '@/components/Themed/Themed';
 import ReplicatorConfigGeneralForm from '@/components/ReplicationConfigGeneralForm/ReplicatorConfigGeneralForm';
 import ReplicatorAuthenticationForm from '@/components/ReplicatorAuthenticationForm/ReplicatorAuthenticationForm';
 import ReplicatorConfigCollectionForm from '@/components/ReplicationConfigCollectionForm/ReplicatorConfigCollectionForm';
 import ResultListView from '@/components/ResultsListView/ResultsListView';
+import ReplicatorContext from '@/providers/ReplicatorContext';
 import { useNavigation } from '@react-navigation/native';
 import useNavigationBarTitleOption from '@/hooks/useNativgationBarTitle';
+import createReplicatorFromConfig from '@/service/replicator/createReplicatorFromConfig';
 
 export default function ReplicationConfigCreateScreen() {
+  const { setReplicatorIds } = useContext(ReplicatorContext)!;
   const styles = useStyleScheme();
   const navigation = useNavigation();
   useNavigationBarTitleOption('Add Replicator Config', navigation);
+
   const [replicatorType, setReplicatorType] = useState<string>('');
   const [connectionString, setConnectionString] = useState<string>('');
   const [heartbeat, setHeartbeat] = useState<string>('300');
@@ -58,6 +62,7 @@ export default function ReplicationConfigCreateScreen() {
     collections: string[]
   ): Promise<void> {
     try {
+      const connStringLower = connectionString.toLowerCase();
       if (replicatorType === '') {
         setResultMessages(['Replicator Type is required']);
         return;
@@ -74,6 +79,39 @@ export default function ReplicationConfigCreateScreen() {
         setResultMessages(['At least one collection is required']);
         return;
       }
+      if (
+        connStringLower === '' ||
+        !connStringLower.startsWith('ws://') ||
+        !connStringLower.startsWith('wss://')
+      ) {
+        setResultMessages(['Connection String is required']);
+        return;
+      }
+      const replicatorId = await createReplicatorFromConfig(
+        setReplicatorIds,
+        database,
+        scopeName,
+        collections,
+        replicatorType,
+        connectionString,
+        heartbeat,
+        maxAttempts,
+        maxWaitTime,
+        continuous,
+        autoPurgeEnabled,
+        acceptParentDomainCookies,
+        acceptOnlySelfSignedCerts,
+        selectedAuthenticationType,
+        username,
+        password,
+        sessionId,
+        cookieName
+      );
+      const date = new Date();
+      setResultMessages((prev) => [
+        ...prev,
+        `${date.toISOString()}:: Replicator created with id: ${replicatorId}`,
+      ]);
     } catch (error) {
       // @ts-ignore
       return [error.message];

expo-example/components/ReplicatorAuthenticationForm/ReplicatorAuthenticationForm.tsx

@@ -90,7 +90,6 @@ export default function ReplicatorAuthenticationForm({
               onChangeText={(newText) => setCookieName(newText)}
               defaultValue={cookieName}
             />
-            <Divider style={localStyles.divider} />
           </>
         ) : null}
       </View>

expo-example/providers/DatabaseProvider.tsx

@@ -1,5 +1,5 @@
 import React, { useState, ReactNode, useMemo } from 'react';
-import { Database, CblReactNativeEngine } from 'cbl-reactnative';
+import { Database, CblReactNativeEngine, Replicator } from 'cbl-reactnative';
 import DatabaseContext from '@/providers/DatabaseContext';
 import ReplicatorContext from '@/providers/ReplicatorContext';
 
@@ -9,9 +9,9 @@ type DatabaseProviderProps = {
 
 const DatabaseProvider: React.FC<DatabaseProviderProps> = ({ children }) => {
   const [databases, setDatabases] = useState<Record<string, Database>>({});
-  const [replicatorIds, setReplicatorIds] = useState<Record<string, string>>(
-    {}
-  );
+  const [replicatorIds, setReplicatorIds] = useState<
+    Record<string, Replicator>
+  >({});
 
   const databasesValue = useMemo(
     () => ({ databases, setDatabases }),

expo-example/service/replicator/createReplicationConfig.ts

@@ -0,0 +1,94 @@
+import {
+  Database,
+  Replicator,
+  ReplicatorConfiguration,
+  BasicAuthenticator,
+  SessionAuthenticator,
+  URLEndpoint,
+  Collection,
+  ReplicatorType,
+} from 'cbl-reactnative';
+import React from 'react';
+
+export default async function createReplicatorFromConfig(
+  setReplicatorIds: React.Dispatch<
+    React.SetStateAction<Record<string, Replicator>>
+  >,
+  database: Database,
+  scopeName: string,
+  collections: string[],
+  replicatorType: string,
+  connectionString: string,
+  heartbeat: string,
+  maxAttempts: string,
+  maxWaitTime: string,
+  continuous: boolean,
+  autoPurgeEnabled: boolean,
+  acceptParentDomainCookies: boolean,
+  acceptOnlySelfSignedCerts: boolean,
+  selectedAuthenticationType: string,
+  username: string | undefined,
+  password: string | undefined,
+  sessionId: string | undefined,
+  cookieName: string | undefined
+): Promise<string> {
+  const target = new URLEndpoint(connectionString);
+  const config = new ReplicatorConfiguration(target);
+  const cols = await getCollections(collections, scopeName, database);
+
+  if (selectedAuthenticationType.toLowerCase() === 'basic') {
+    const uname = username || '';
+    const pwd = password || '';
+    config.setAuthenticator(new BasicAuthenticator(uname, pwd));
+  } else {
+    const session = sessionId || '';
+    const cookie = cookieName || '';
+    config.setAuthenticator(new SessionAuthenticator(session, cookie));
+  }
+
+  config.addCollections(cols);
+  config.setReplicatorType(getReplicationType(replicatorType));
+  config.setHeartbeat(parseInt(heartbeat, 10));
+  config.setMaxAttempts(parseInt(maxAttempts, 10));
+  config.setMaxAttemptWaitTime(parseInt(maxWaitTime, 10));
+  config.setContinuous(continuous);
+  config.setAutoPurgeEnabled(autoPurgeEnabled);
+  config.setAcceptParentDomainCookies(acceptParentDomainCookies);
+  config.setAcceptOnlySelfSignedCerts(acceptOnlySelfSignedCerts);
+  const replicator = await Replicator.create(config);
+  const uuid = replicator.getId();
+  if (uuid !== undefined && uuid !== '') {
+    setReplicatorIds((prev) => {
+      return { ...prev, [uuid]: replicator };
+    });
+    return uuid;
+  } else {
+    throw new Error("Can't create replicator - id is undefined");
+  }
+}
+
+async function getCollections(
+  collections: string[],
+  scopeName: string,
+  database: Database
+): Promise<Collection[]> {
+  const resultsCollections: Collection[] = [];
+  collections.map(async (collectionName) => {
+    const collection = await database.collection(scopeName, collectionName);
+    resultsCollections.push(collection);
+  });
+  return resultsCollections;
+}
+
+function getReplicationType(replicatorType: string): ReplicatorType {
+  switch (replicatorType) {
+    case 'PUSH':
+      return ReplicatorType.PUSH;
+    case 'PULL':
+      return ReplicatorType.PULL;
+    case 'PUSH AND PULL':
+      return ReplicatorType.PUSH_AND_PULL;
+    default:
+      return ReplicatorType.PUSH_AND_PULL;
+  }
+}

expo-example/service/replicator/createReplicatorFromConfig.ts

@@ -1,7 +1,8 @@
 import React from 'react';
+import { Replicator } from 'cbl-reactnative';
 export type ReplicatorContextType = {
-  replicatorIds: Record<string, string>;
+  replicatorIds: Record<string, Replicator>;
   setReplicatorIds: React.Dispatch<
-    React.SetStateAction<Record<string, string>>
+    React.SetStateAction<Record<string, Replicator>>
   >;
 };