feat: Add support for MongoDB $search operator

src/ParseQuery.ts

@@ -37,6 +37,10 @@
   diacriticSensitive?: boolean;
 };
 
+type SearchOptions = {
+  index?: string;
+};
+
 export type QueryJSON = {
   where: WhereClause;
   watch?: string;
@@ -1587,6 +1591,48 @@
     return this._addCondition(key, '$text', { $search: fullOptions });
   }
 
+  /*
+   * Triggers a MongoDb Atlas Text Search
+   *
+   * @param {string} value The string to search
+   * @param {string[]} path The fields to search
+   * @param {object} options (Optional)
+   * @param {string} options.index The index to search
+   * @returns {Promise} Returns a promise that will be resolved with the results
+   * of the search
+   * */
+
+  async search(value: string, path: string[], options: SearchOptions = {}): Promise<Array<any>> {
+    if (!value) {
+      throw new Error('A search term is required.');
+    }
+
+    if (typeof value !== 'string') {
+      throw new Error('The value being searched for must be a string.');
+    }
+
+    const controller = CoreManager.getQueryController();
+    const params = {
+      $search: {
+        index: options.index || 'default',
+        text: {
+          path,
+          query: value,
+        },
+      },
+    };
+
+    const searchOptions: { sessionToken?: string; useMasterKey: boolean } = {
+      useMasterKey: true,
+    };
+    const results = await controller.aggregate(this.className, params, searchOptions);
+    return (
+      results.results?.map(result =>
+        ParseObject.fromJSON({ className: this.className, ...result })
+      ) || []
+    );
+  }
+
   /**
    * Method to sort the full text search by text score
    *

src/__tests__/ParseQuery-test.js

@@ -2709,6 +2709,40 @@ describe('ParseQuery', () => {
     });
   });
 
+  it('can issue a search query', async () => {
+    CoreManager.setQueryController({
+      find() {},
+      aggregate(className, params, options) {
+        expect(className).toBe('Item');
+        expect(params).toEqual({
+          $search: {
+            index: 'searchIndex',
+            text: {
+              path: ['name'],
+              query: 'searchTerm',
+            },
+          },
+        });
+        expect(options.useMasterKey).toEqual(true);
+        return Promise.resolve({
+          results: [],
+        });
+      },
+    });
+    const q = new ParseQuery('Item');
+    await q.search('searchTerm', ['name'], { index: 'searchIndex' });
+  });
+
+  it('search term is required', async () => {
+    const q = new ParseQuery('Item');
+    await expect(q.search()).rejects.toThrow('A search term is required.');
+  });
+
+  it('search term must be a string', async () => {
+    const q = new ParseQuery('Item');
+    await expect(q.search(123)).rejects.toThrow('The value being searched for must be a string.');
+  });
+
   it('aggregate query array pipeline with equalTo', done => {
     const pipeline = [{ group: { objectId: '$name' } }];
     MockRESTController.request.mockImplementationOnce(() => {

types/ParseQuery.d.ts

@@ -29,6 +29,9 @@ type FullTextQueryOptions = {
     caseSensitive?: boolean;
     diacriticSensitive?: boolean;
 };
+type SearchOptions = {
+    index?: string;
+};
 export type QueryJSON = {
     where: WhereClause;
     watch?: string;
@@ -642,6 +645,7 @@ declare class ParseQuery<T extends ParseObject = ParseObject> {
      * @returns {Parse.Query} Returns the query, so you can chain this call.
      */
     fullText<K extends keyof T['attributes'] | keyof BaseAttributes>(key: K, value: string, options?: FullTextQueryOptions): this;
+    search(value: string, path: string[], options?: SearchOptions): Promise<Array<any>>;
     /**
      * Method to sort the full text search by text score
      *