280 add documentdb interoperability

app/repository/_base.repository.js

@@ -76,24 +76,29 @@ class BaseRepository extends AbstractRepository {
         aggregation.push(match);
       }
 
-      const facet = {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [],
-        },
-      };
+      // Get the total count of documents, pre-limit
+      const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
       if (options.offset) {
-        facet.$facet.documents.push({ $skip: options.offset });
+        aggregation.push({ $skip: options.offset });
       } else {
-        facet.$facet.documents.push({ $skip: 0 });
+        aggregation.push({ $skip: 0 });
       }
+
       if (options.limit) {
-        facet.$facet.documents.push({ $limit: options.limit });
+        aggregation.push({ $limit: options.limit });
       }
-      aggregation.push(facet);
 
       // Retrieve the documents
-      return await this.model.aggregate(aggregation).exec();
+      const documents = await this.model.aggregate(aggregation).exec();
+
+      // Return data in the format previously given by $facet
+      return [
+        {
+          totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+          documents: documents,
+        },
+      ];
     } catch (err) {
       throw new DatabaseError(err);
     }

app/repository/assets-repository.js

@@ -70,24 +70,29 @@ class AssetsRepository extends BaseRepository {
         aggregation.push(match);
       }
 
-      const facet = {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [],
-        },
-      };
+      // Get the total count of documents, pre-limit
+      const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
       if (options.offset) {
-        facet.$facet.documents.push({ $skip: options.offset });
+        aggregation.push({ $skip: options.offset });
       } else {
-        facet.$facet.documents.push({ $skip: 0 });
+        aggregation.push({ $skip: 0 });
       }
+
       if (options.limit) {
-        facet.$facet.documents.push({ $limit: options.limit });
+        aggregation.push({ $limit: options.limit });
       }
-      aggregation.push(facet);
 
       // Retrieve the documents
-      return await this.model.aggregate(aggregation).exec();
+      const documents = await this.model.aggregate(aggregation).exec();
+
+      // Return data in the format previously given by $facet
+      return [
+        {
+          totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+          documents: documents,
+        },
+      ];
     } catch (err) {
       throw new DatabaseError(err);
     }

app/repository/attack-objects-repository.js

@@ -65,24 +65,29 @@ class AttackObjectsRepository extends BaseRepository {
       aggregation.push(match);
     }
 
-    const facet = {
-      $facet: {
-        totalCount: [{ $count: 'totalCount' }],
-        documents: [],
-      },
-    };
+    // Get the total count of documents, pre-limit
+    const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
     if (options.offset) {
-      facet.$facet.documents.push({ $skip: options.offset });
+      aggregation.push({ $skip: options.offset });
     } else {
-      facet.$facet.documents.push({ $skip: 0 });
+      aggregation.push({ $skip: 0 });
     }
+
     if (options.limit) {
-      facet.$facet.documents.push({ $limit: options.limit });
+      aggregation.push({ $limit: options.limit });
     }
-    aggregation.push(facet);
 
     // Retrieve the documents
-    return await this.model.aggregate(aggregation).exec();
+    const documents = await this.model.aggregate(aggregation).exec();
+
+    // Return data in the format previously given by $facet
+    return [
+      {
+        totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+        documents: documents,
+      },
+    ];
   }
 }
 

app/repository/notes-repository.js

@@ -57,24 +57,29 @@ class NotesRepository extends BaseRepository {
         aggregation.push(match);
       }
 
-      const facet = {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [],
-        },
-      };
+      // Get the total count of documents, pre-limit
+      const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
       if (options.offset) {
-        facet.$facet.documents.push({ $skip: options.offset });
+        aggregation.push({ $skip: options.offset });
       } else {
-        facet.$facet.documents.push({ $skip: 0 });
+        aggregation.push({ $skip: 0 });
       }
+
       if (options.limit) {
-        facet.$facet.documents.push({ $limit: options.limit });
+        aggregation.push({ $limit: options.limit });
       }
-      aggregation.push(facet);
 
       // Retrieve the documents
-      return await this.model.aggregate(aggregation).exec();
+      const documents = await this.model.aggregate(aggregation).exec();
+
+      // Return data in the format previously given by $facet
+      return [
+        {
+          totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+          documents: documents,
+        },
+      ];
     } catch (err) {
       throw new DatabaseError(err);
     }

app/repository/references-repository.js

@@ -30,24 +30,29 @@ class ReferencesRepository {
     aggregation.push({ $sort: { source_name: 1 } });
     aggregation.push({ $match: query });
 
-    const facet = {
-      $facet: {
-        totalCount: [{ $count: 'totalCount' }],
-        documents: [],
-      },
-    };
+    // Get the total count of documents, pre-limit
+    const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
     if (options.offset) {
-      facet.$facet.documents.push({ $skip: options.offset });
+      aggregation.push({ $skip: options.offset });
     } else {
-      facet.$facet.documents.push({ $skip: 0 });
+      aggregation.push({ $skip: 0 });
     }
+
     if (options.limit) {
-      facet.$facet.documents.push({ $limit: options.limit });
+      aggregation.push({ $limit: options.limit });
     }
-    aggregation.push(facet);
 
     // Retrieve the documents
-    return await this.model.aggregate(aggregation).exec();
+    const documents = await this.model.aggregate(aggregation).exec();
+
+    // Return data in the format previously given by $facet
+    return [
+      {
+        totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+        documents: documents,
+      },
+    ];
   }
 
   async save(data) {

app/repository/teams-repository.js

@@ -15,22 +15,32 @@ class TeamsRepository {
     this.model = model;
   }
 
-  retrieveByUserId(userAccountId, options) {
-    const aggregation = [
-      { $sort: { name: 1 } },
-      { $match: { userIDs: { $in: [userAccountId] } } },
+  async retrieveByUserId(userAccountId, options) {
+    const aggregation = [{ $sort: { name: 1 } }, { $match: { userIDs: { $in: [userAccountId] } } }];
+
+    // Get the total count of documents, pre-limit
+    const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
+    if (options.offset) {
+      aggregation.push({ $skip: options.offset });
+    } else {
+      aggregation.push({ $skip: 0 });
+    }
+
+    if (options.limit) {
+      aggregation.push({ $limit: options.limit });
+    }
+
+    // Retrieve the documents
+    const documents = await this.model.aggregate(aggregation).exec();
+
+    // Return data in the format previously given by $facet
+    return [
       {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [
-            { $skip: options.offset || 0 },
-            ...(options.limit ? [{ $limit: options.limit }] : []),
-          ],
-        },
+        totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+        documents: documents,
       },
     ];
-
-    return this.model.aggregate(aggregation).exec();
   }
 
   async retrieveAll(options) {
@@ -50,24 +60,29 @@ class TeamsRepository {
       aggregation.push(match);
     }
 
-    const facet = {
-      $facet: {
-        totalCount: [{ $count: 'totalCount' }],
-        documents: [],
-      },
-    };
+    // Get the total count of documents, pre-limit
+    const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
+
     if (options.offset) {
-      facet.$facet.documents.push({ $skip: options.offset });
+      aggregation.push({ $skip: options.offset });
     } else {
-      facet.$facet.documents.push({ $skip: 0 });
+      aggregation.push({ $skip: 0 });
     }
+
     if (options.limit) {
-      facet.$facet.documents.push({ $limit: options.limit });
+      aggregation.push({ $limit: options.limit });
     }
-    aggregation.push(facet);
 
     // Retrieve the documents
-    return await this.model.aggregate(aggregation);
+    const documents = await this.model.aggregate(aggregation).exec();
+
+    // Return data in the format previously given by $facet
+    return [
+      {
+        totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+        documents: documents,
+      },
+    ];
   }
 
   async retrieveById(teamId) {

app/repository/user-accounts-repository.js

@@ -48,27 +48,29 @@ class UserAccountsRepository {
         aggregation.push(match);
       }
 
-      const facet = {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [],
-        },
-      };
+      // Get the total count of documents, pre-limit
+      const totalCount = await this.model.aggregate(aggregation).count('totalCount').exec();
 
       if (options.offset) {
-        facet.$facet.documents.push({ $skip: options.offset });
+        aggregation.push({ $skip: options.offset });
       } else {
-        facet.$facet.documents.push({ $skip: 0 });
+        aggregation.push({ $skip: 0 });
       }
 
       if (options.limit) {
-        facet.$facet.documents.push({ $limit: options.limit });
+        aggregation.push({ $limit: options.limit });
       }
 
-      aggregation.push(facet);
-
       // Retrieve the documents
-      return await this.model.aggregate(aggregation).exec();
+      const documents = await this.model.aggregate(aggregation).exec();
+
+      // Return data in the format previously given by $facet
+      return [
+        {
+          totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+          documents: documents,
+        },
+      ];
     } catch (err) {
       throw new DatabaseError(err);
     }

app/services/teams-service.js

@@ -118,23 +118,30 @@ class TeamsService {
         };
         aggregation.push(match);
       }
-      const facet = {
-        $facet: {
-          totalCount: [{ $count: 'totalCount' }],
-          documents: [],
-        },
-      };
+      // Get the total count of documents, pre-limit
+      const totalCount = await UserAccount.aggregate(aggregation).count('totalCount').exec();
+
       if (options.offset) {
-        facet.$facet.documents.push({ $skip: options.offset });
+        aggregation.push({ $skip: options.offset });
       } else {
-        facet.$facet.documents.push({ $skip: 0 });
+        aggregation.push({ $skip: 0 });
       }
+
       if (options.limit) {
-        facet.$facet.documents.push({ $limit: options.limit });
+        aggregation.push({ $limit: options.limit });
       }
-      aggregation.push(facet);
+
+      // Retrieve the documents
+      const documents = await UserAccount.aggregate(aggregation).exec();
+
+      const results = [
+        {
+          totalCount: [{ totalCount: totalCount[0]?.totalCount || 0 }],
+          documents: documents,
+        },
+      ];
+
       try {
-        const results = await UserAccount.aggregate(aggregation);
         const userAccounts = results[0].documents;
         userAccounts.forEach((userAccount) => {
           userAccountsService.constructor.addEffectiveRole(userAccount);
@@ -145,13 +152,9 @@ class TeamsService {
         });
 
         if (options.includePagination) {
-          let derivedTotalCount = 0;
-          if (results[0].totalCount.length > 0) {
-            derivedTotalCount = results[0].totalCount[0].totalCount;
-          }
           const returnValue = {
             pagination: {
-              total: derivedTotalCount,
+              total: results[0].totalCount[0].totalCount,
               offset: options.offset,
               limit: options.limit,
             },