@powersync/service-module-mongodb 0.3.1 → 0.4.1

package/src/replication/ChangeStream.ts

@@ -1,5 +1,12 @@
 import { mongo } from '@powersync/lib-service-mongodb';
-import { container, logger } from '@powersync/lib-services-framework';
+import {
+  container,
+  ErrorCode,
+  logger,
+  ReplicationAbortedError,
+  ReplicationAssertionError,
+  ServiceError
+} from '@powersync/lib-services-framework';
 import { Metrics, SaveOperationTag, SourceEntityDescriptor, SourceTable, storage } from '@powersync/service-core';
 import { DatabaseInputRow, SqliteRow, SqlSyncRules, TablePattern } from '@powersync/service-sync-rules';
 import { PostImagesOption } from '../types/types.js';
@@ -180,12 +187,18 @@ export class ChangeStream {
     const hello = await this.defaultDb.command({ hello: 1 });
     const snapshotTime = hello.lastWrite?.majorityOpTime?.ts as mongo.Timestamp;
     if (hello.msg == 'isdbgrid') {
-      throw new Error('Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).');
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1341,
+        'Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).'
+      );
     } else if (hello.setName == null) {
-      throw new Error('Standalone MongoDB instances are not supported - use a replicaset.');
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1342,
+        'Standalone MongoDB instances are not supported - use a replicaset.'
+      );
     } else if (snapshotTime == null) {
       // Not known where this would happen apart from the above cases
-      throw new Error('MongoDB lastWrite timestamp not found.');
+      throw new ReplicationAssertionError('MongoDB lastWrite timestamp not found.');
     }
     // We previously used {snapshot: true} for the snapshot session.
     // While it gives nice consistency guarantees, it fails when the
@@ -294,7 +307,7 @@ export class ChangeStream {
 
     for await (let document of cursor) {
       if (this.abort_signal.aborted) {
-        throw new Error(`Aborted initial replication`);
+        throw new ReplicationAbortedError(`Aborted initial replication`);
       }
 
       at += 1;
@@ -367,7 +380,7 @@ export class ChangeStream {
       });
       logger.info(`Enabled postImages on ${db}.${collectionInfo.name}`);
     } else if (!enabled) {
-      throw new Error(`postImages not enabled on ${db}.${collectionInfo.name}`);
+      throw new ServiceError(ErrorCode.PSYNC_S1343, `postImages not enabled on ${db}.${collectionInfo.name}`);
     }
   }
 
@@ -385,7 +398,7 @@ export class ChangeStream {
 
     const snapshot = options.snapshot;
     if (!descriptor.objectId && typeof descriptor.objectId != 'string') {
-      throw new Error('objectId expected');
+      throw new ReplicationAssertionError('MongoDB replication - objectId expected');
     }
     const result = await this.storage.resolveTable({
       group_id: this.group_id,
@@ -466,7 +479,7 @@ export class ChangeStream {
         beforeReplicaId: change.documentKey._id
       });
     } else {
-      throw new Error(`Unsupported operation: ${change.operationType}`);
+      throw new ReplicationAssertionError(`Unsupported operation: ${change.operationType}`);
     }
   }
 
@@ -607,7 +620,7 @@ export class ChangeStream {
             }
           } else if (splitDocument != null) {
             // We were waiting for fragments, but got a different event
-            throw new Error(`Incomplete splitEvent: ${JSON.stringify(splitDocument.splitEvent)}`);
+            throw new ReplicationAssertionError(`Incomplete splitEvent: ${JSON.stringify(splitDocument.splitEvent)}`);
           }
 
           // console.log('event', changeDocument);

package/src/replication/ChangeStreamReplicator.ts

@@ -2,6 +2,7 @@ import { storage, replication } from '@powersync/service-core';
 import { ChangeStreamReplicationJob } from './ChangeStreamReplicationJob.js';
 import { ConnectionManagerFactory } from './ConnectionManagerFactory.js';
 import { MongoErrorRateLimiter } from './MongoErrorRateLimiter.js';
+import { MongoModule } from '../module/MongoModule.js';
 
 export interface ChangeStreamReplicatorOptions extends replication.AbstractReplicatorOptions {
   connectionFactory: ConnectionManagerFactory;
@@ -33,4 +34,8 @@ export class ChangeStreamReplicator extends replication.AbstractReplicator<Chang
     await super.stop();
     await this.connectionFactory.shutdown();
   }
+
+  async testConnection() {
+    return await MongoModule.testConnection(this.connectionFactory.dbConnectionConfig);
+  }
 }

package/src/replication/ConnectionManagerFactory.ts

@@ -4,7 +4,7 @@ import { MongoManager } from './MongoManager.js';
 
 export class ConnectionManagerFactory {
   private readonly connectionManagers: MongoManager[];
-  private readonly dbConnectionConfig: NormalizedMongoConnectionConfig;
+  public readonly dbConnectionConfig: NormalizedMongoConnectionConfig;
 
   constructor(dbConnectionConfig: NormalizedMongoConnectionConfig) {
     this.dbConnectionConfig = dbConnectionConfig;

package/src/replication/MongoManager.ts

@@ -19,6 +19,8 @@ export class MongoManager {
         username: options.username,
         password: options.password
       },
+
+      lookup: options.lookup,
       // Time for connection to timeout
       connectTimeoutMS: 5_000,
       // Time for individual requests to timeout

package/src/replication/MongoRelation.ts

@@ -4,6 +4,7 @@ import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
 import { SqliteRow, SqliteValue } from '@powersync/service-sync-rules';
 
 import { CHECKPOINTS_COLLECTION } from './replication-utils.js';
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 
 export function getMongoRelation(source: mongo.ChangeStreamNameSpace): storage.SourceEntityDescriptor {
   return {
@@ -97,7 +98,7 @@ function filterJsonData(data: any, depth = 0): any {
   const autoBigNum = true;
   if (depth > DEPTH_LIMIT) {
     // This is primarily to prevent infinite recursion
-    throw new Error(`json nested object depth exceeds the limit of ${DEPTH_LIMIT}`);
+    throw new ServiceError(ErrorCode.PSYNC_S1004, `json nested object depth exceeds the limit of ${DEPTH_LIMIT}`);
   }
   if (data === null) {
     return data;

package/src/replication/replication-utils.ts

@@ -1,13 +1,88 @@
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 import { MongoManager } from './MongoManager.js';
+import { PostImagesOption } from '../types/types.js';
 
 export const CHECKPOINTS_COLLECTION = '_powersync_checkpoints';
 
+const REQUIRED_CHECKPOINT_PERMISSIONS = ['find', 'insert', 'update', 'remove', 'changeStream', 'createCollection'];
+
 export async function checkSourceConfiguration(connectionManager: MongoManager): Promise<void> {
   const db = connectionManager.db;
+
   const hello = await db.command({ hello: 1 });
   if (hello.msg == 'isdbgrid') {
-    throw new Error('Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).');
+    throw new ServiceError(
+      ErrorCode.PSYNC_S1341,
+      'Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).'
+    );
   } else if (hello.setName == null) {
-    throw new Error('Standalone MongoDB instances are not supported - use a replicaset.');
+    throw new ServiceError(ErrorCode.PSYNC_S1342, 'Standalone MongoDB instances are not supported - use a replicaset.');
+  }
+
+  // https://www.mongodb.com/docs/manual/reference/command/connectionStatus/
+  const connectionStatus = await db.command({ connectionStatus: 1, showPrivileges: true });
+  const priviledges = connectionStatus.authInfo?.authenticatedUserPrivileges as {
+    resource: { db: string; collection: string };
+    actions: string[];
+  }[];
+  let checkpointsActions = new Set<string>();
+  let anyCollectionActions = new Set<string>();
+  if (priviledges?.length > 0) {
+    const onDefaultDb = priviledges.filter((p) => p.resource.db == db.databaseName || p.resource.db == '');
+    const onCheckpoints = onDefaultDb.filter(
+      (p) => p.resource.collection == CHECKPOINTS_COLLECTION || p.resource?.collection == ''
+    );
+
+    for (let p of onCheckpoints) {
+      for (let a of p.actions) {
+        checkpointsActions.add(a);
+      }
+    }
+    for (let p of onDefaultDb) {
+      for (let a of p.actions) {
+        anyCollectionActions.add(a);
+      }
+    }
+
+    const missingCheckpointActions = REQUIRED_CHECKPOINT_PERMISSIONS.filter(
+      (action) => !checkpointsActions.has(action)
+    );
+    if (missingCheckpointActions.length > 0) {
+      const fullName = `${db.databaseName}.${CHECKPOINTS_COLLECTION}`;
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1307,
+        `MongoDB user does not have the required ${missingCheckpointActions.map((a) => `"${a}"`).join(', ')} priviledge(s) on "${fullName}".`
+      );
+    }
+
+    if (connectionManager.options.postImages == PostImagesOption.AUTO_CONFIGURE) {
+      // This checks that we have collMod on _any_ collection in the db.
+      // This is not a complete check, but does give a basic sanity-check for testing the connection.
+      if (!anyCollectionActions.has('collMod')) {
+        throw new ServiceError(
+          ErrorCode.PSYNC_S1307,
+          `MongoDB user does not have the required "collMod" priviledge on "${db.databaseName}", required for "post_images: auto_configure".`
+        );
+      }
+    }
+    if (!anyCollectionActions.has('listCollections')) {
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1307,
+        `MongoDB user does not have the required "listCollections" priviledge on "${db.databaseName}".`
+      );
+    }
+  } else {
+    // Assume auth is disabled.
+    // On Atlas, at least one role/priviledge is required for each user, which will trigger the above.
+
+    // We do still do a basic check that we can list the collection (it may not actually exist yet).
+    await db
+      .listCollections(
+        {
+          name: CHECKPOINTS_COLLECTION
+        },
+        { nameOnly: false }
+      )
+      .toArray();
   }
 }

package/src/types/types.ts

@@ -1,5 +1,6 @@
 import * as lib_mongo from '@powersync/lib-service-mongodb/types';
 import * as service_types from '@powersync/service-types';
+import { LookupFunction } from 'node:net';
 import * as t from 'ts-codec';
 
 export enum PostImagesOption {
@@ -48,6 +49,8 @@ export interface NormalizedMongoConnectionConfig {
   username?: string;
   password?: string;
 
+  lookup?: LookupFunction;
+
   postImages: PostImagesOption;
 }