mongodb-atlas-api-client 2.24.0 → 2.25.0

package/README.md

@@ -64,6 +64,7 @@ Following entities are currently supported
 - [Event](#event)
 - [Alert](#alert)
 - [DataLake](#datalake)
+- [AtlasSearch](#atlassearch)
 
 ### User
 
@@ -857,4 +858,98 @@ Function - Deletes the cloudProviderAccess name passed.
 
 More details - https://docs.atlas.mongodb.com/reference/api/cloud-provider-access-deauthorize-one-role/
 
+### AtlasSearch
+
+### atlasSearch.get(clusterName, indexId, [options]) ⇒ <code>Promise</code>
+Function - Returns the details of atlas search index by cluster name and index passed.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be retrieved |
+| indexId | <code>String</code> |  | id of the index for which details needs to be retrieved |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-indexes-get-one/
+
+### atlasSearch.getAll(clusterName, databaseName, collectionName, [options]) ⇒ <code>Promise</code>
+Function - Returns all the atlas search indexes. Pagination can be controlled via options object.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be retrieved |
+| databaseName | <code>String</code> |  | name of the database for which details needs to be retrieved |
+| collectionName | <code>String</code> |  | name of the collection for which details needs to be retrieved |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-indexes-get-all/
+
+### atlasSearch.getAllAnalyzers(clusterName, [options]) ⇒ <code>Promise</code>
+Function - Returns all the Analyzers. Pagination can be controlled via options object.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be retrieved |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-analyzers-get-all/
+
+### atlasSearch.create(clusterName, body, [options]) ⇒ <code>Promise</code>
+Function - Creates the atlas search index as per body passed.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be retrieved |
+| body | <code>Object</code> |  | Body which has details for cluster which needs to be created |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-indexes-create-one/
+
+### atlasSearch.update(clusterName, indexId, body, [options]) ⇒ <code>Promise</code>
+Function - Updates the atlas search index for the clusterName passed. It only updates the properties passed in body.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be updated |
+| indexId | <code>String</code> |  | name of the index for which details needs to be updated |
+| body | <code>Object</code> |  | Body which has details for cluster which needs to be updated |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-indexes-update-one/
+
+### atlasSearch.upsertAnalyzer(clusterName, body, [options]) ⇒ <code>Promise</code>
+Function - Upserts the analyser for the clusterName passed.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster for which details needs to be upserted |
+| body | <code>Object</code> |  | Body which has details for cluster which needs to be upserted |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-analyzers-update-all/
+
+### atlasSearch.delete(clusterName, indexId, [options]) ⇒ <code>Promise</code>
+Function - Deletes the atlas search index by cluster name passed.
+
+**Returns**: <code>Promise</code> - - promise which resolves on success and rejects on error  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| clusterName | <code>String</code> |  | name of the cluster which needs to be deleted |
+| indexId | <code>String</code> |  | name of the index for which details needs to be deleted |
+| [options] | <code>Object</code> | <code>{}</code> | Optional object containing extra query strings which will be passed to atlas api |
+
+More details - https://docs.atlas.mongodb.com/reference/api/fts-indexes-delete-one/
+
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-atlas-api-client",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "A mongodb atlas api client for nodejs.",
   "main": "src/index.js",
   "scripts": {
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "digest-fetch": "^1.1.6",
-    "node-fetch": "^2.6.1",
+    "node-fetch": "^2.6.5",
     "qs": "^6.9.6"
   }
 }

package/src/atlasSearch.d.ts

@@ -0,0 +1,17 @@
+import {AtlasClientOptions, AtlasError} from '.';
+
+// DataLakeClient
+export type ClusterName = string;
+export type IndexId = string;
+export type DatabaseName = string;
+export type CollectionName = string;
+
+export interface AtlasSearch {
+    get(clusterName: ClusterName, indexId: IndexId, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    getAll(clusterName: ClusterName, databaseName: DatabaseName, collectionName: CollectionName, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    delete(clusterName: ClusterName, indexId: IndexId, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    update(clusterName: ClusterName, indexId: IndexId, body: object, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    create(clusterName: ClusterName, body: object, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    getAllAnalyzers(clusterName: ClusterName, options?: AtlasClientOptions): Promise<any | AtlasError>;
+    upsertAnalyzer(clusterName: ClusterName, body: object, options?: AtlasClientOptions): Promise<any | AtlasError>;
+}

package/src/atlasSearch.js

@@ -0,0 +1,81 @@
+const qs = require("qs");
+
+class AtlasSearch {
+
+  constructor(client, baseUrl, projectId) {
+    this.client_ = client;
+    this.baseUrl_ = baseUrl;
+    this.projectId_ = projectId;
+  }
+
+  async get(clusterName, indexId, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/indexes/${indexId}?${queryString}`)
+    ).json();
+    return response;
+  }
+
+  async getAllAnalyzers(clusterName, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/analyzers?${queryString}`)
+    ).json();
+    return response;
+  }
+
+  async upsertAnalyzer(clusterName, body, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/analyzers?${queryString}`, {
+        "method": "PUT",
+        "body": JSON.stringify(body),
+        "headers": {"Content-Type": "application/json"}
+      })
+    ).json();
+    return response;
+  }
+
+  async getAll(clusterName, databaseName, collectionName, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/indexes/${databaseName}/${collectionName}?${queryString}`)
+    ).json();
+    return response;
+  }
+
+  async delete(clusterName, indexId, options) {
+    const queryString = qs.stringify(options);
+    await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/indexes/${indexId}?${queryString}`, {
+      "method": "DELETE"
+    });
+    return true;
+  }
+
+  async update(clusterName, indexId, body, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/indexes/${indexId}?${queryString}`, {
+        "method": "PATCH",
+        "body": JSON.stringify(body),
+        "headers": {"Content-Type": "application/json"}
+      })
+    ).json();
+    return response;
+  }
+
+  async create(clusterName, body, options) {
+    const queryString = qs.stringify(options);
+    const response = (
+      await this.client_.fetch(`${this.baseUrl_}/groups/${this.projectId_}/clusters/${clusterName}/fts/indexes?${queryString}`, {
+        "method": "POST",
+        "body": JSON.stringify(body),
+        "headers": {"Content-Type": "application/json"}
+      })
+    ).json();
+    return response;
+  }
+}
+
+module.exports = AtlasSearch;
+

package/src/index.d.ts

@@ -10,6 +10,7 @@ import {ProjectAccesslist} from './projectAccesslist';
 import {User} from './user';
 import {DataLake} from './dataLake';
 import {CloudProviderAccess} from './cloudProviderAccess';
+import {AtlasSearch} from './atlasSearch';
 
 export * from './alert'
 export * from './atlasUser';
@@ -23,6 +24,7 @@ export * from './projectAccesslist';
 export * from './user';
 export * from './dataLake'
 export * from './cloudProviderAccess';
+export * from './atlasSearch';
 
 export interface KeyValuePairDocument {
     key: string;
@@ -67,6 +69,7 @@ export interface AtlasClient {
     event: Event;
     dataLake: DataLake;
     cloudProviderAccess: CloudProviderAccess;
+    atlasSearch: AtlasSearch
 }
 
 export interface AtlasClientConfig {

package/src/index.js

@@ -10,6 +10,7 @@ const Event = require("./event");
 const Alert = require("./alert");
 const DataLake = require("./dataLake");
 const CloudProviderAccess = require("./cloudProviderAccess");
+const AtlasSearch = require("./atlasSearch");
 const DigestFetch = require("digest-fetch");
 
 function getFunctions(instance) {
@@ -40,6 +41,7 @@ function getMongodbAtlasApiClient(options) {
   const alert = new Alert(client, options.baseUrl, options.projectId);
   const dataLake = new DataLake(client, options.baseUrl, options.projectId);
   const cloudProviderAccess = new CloudProviderAccess(client, options.baseUrl, options.projectId);
+  const atlasSearch = new AtlasSearch(client, options.baseUrl, options.projectId);
 
   const functions = {};
   functions.user = getFunctions(user);
@@ -54,6 +56,7 @@ function getMongodbAtlasApiClient(options) {
   functions.alert = getFunctions(alert);
   functions.dataLake = getFunctions(dataLake);
   functions.cloudProviderAccess = getFunctions(cloudProviderAccess);
+  functions.atlasSearch = getFunctions(atlasSearch);
 
   return functions;
 }

package/test/atlasSearch.test.js

@@ -0,0 +1,106 @@
+const {describe, it} = exports.lab = require("@hapi/lab").script();
+const {expect} = require("@hapi/code");
+const nock = require("nock");
+const getClient = require("../src");
+
+const baseUrl = "http://dummyBaseUrl";
+const projectId = "dummyProjectId";
+
+const client = getClient({
+  "publicKey": "dummuyPublicKey",
+  "privateKey": "dummyPrivateKey",
+  "baseUrl": baseUrl,
+  "projectId": projectId
+});
+
+describe("Mongo Atlas Api Client - atlasSearch", () => {
+
+  describe("When atlasSearch is exported from index", () => {
+    it("should export atlasSearch functions", async () => {
+      expect(client.atlasSearch.get).to.be.function();
+      expect(client.atlasSearch.getAll).to.be.function();
+      expect(client.atlasSearch.create).to.be.function();
+      expect(client.atlasSearch.delete).to.be.function();
+      expect(client.atlasSearch.update).to.be.function();
+      expect(client.atlasSearch.getAllAnalyzers).to.be.function();
+      expect(client.atlasSearch.upsertAnalyzer).to.be.function();
+    });
+  });
+
+  describe("When get is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .get(`/groups/${projectId}/clusters/mycluster/fts/indexes/myindexId?key1=value1&key2=value2`)
+        .reply(200, {"atlasSearch": "name"});
+      const result = await client.atlasSearch.get("mycluster", "myindexId", {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal({"atlasSearch": "name"});
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When getAll is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .get(`/groups/${projectId}/clusters/mycluster/fts/indexes/mydatabasename/mycollectionname?key1=value1&key2=value2`)
+        .reply(200, [{"atlasSearch": "name"}]);
+      const result = await client.atlasSearch.getAll("mycluster", "mydatabasename", "mycollectionname", {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal([{"atlasSearch": "name"}]);
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When getAllAnalyzers is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .get(`/groups/${projectId}/clusters/mycluster/fts/analyzers?key1=value1&key2=value2`)
+        .reply(200, [{"atlasSearch": "name"}]);
+      const result = await client.atlasSearch.getAllAnalyzers("mycluster", {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal([{"atlasSearch": "name"}]);
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When update is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .patch(`/groups/${projectId}/clusters/mycluster/fts/indexes/indexId?key1=value1&key2=value2`)
+        .reply(200, [{"atlasSearch": "name"}]);
+      const result = await client.atlasSearch.update("mycluster", "indexId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal([{"atlasSearch": "name"}]);
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When upsertAnalyzer is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .put(`/groups/${projectId}/clusters/mycluster/fts/analyzers?key1=value1&key2=value2`)
+        .reply(200, [{"atlasSearch": "name"}]);
+      const result = await client.atlasSearch.upsertAnalyzer("mycluster", {"body": "value"}, {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal([{"atlasSearch": "name"}]);
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When create is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .post(`/groups/${projectId}/clusters/mycluster/fts/indexes?key1=value1&key2=value2`)
+        .reply(200, [{"atlasSearch": "name"}]);
+      const result = await client.atlasSearch.create("mycluster", {"body": "value"}, {"key1": "value1", "key2": "value2"});
+      expect(result).to.equal([{"atlasSearch": "name"}]);
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+
+  describe("When delete is called with querystring parameters", () => {
+    it("should return response", async () => {
+      const expectedRequest = nock(baseUrl)
+        .delete(`/groups/${projectId}/clusters/mycluster/fts/indexes/indexId?key1=value1&key2=value2`)
+        .reply(200, true);
+      const result = await client.atlasSearch.delete("mycluster", "indexId", {"key1": "value1", "key2": "value2"});
+      expect(result).to.be.true();
+      expect(expectedRequest.isDone()).to.be.true();
+    });
+  });
+});