monday-sdk-js 0.3.0 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monday-sdk-js",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "private": false,
   "repository": "https://github.com/mondaycom/monday-sdk-js",
   "main": "src/index.js",

package/src/client-test.js

@@ -33,30 +33,30 @@ describe("Monday Client Test", () => {
 
   describe("setters", () => {
     it("should set client id correctly", () => {
-      const newId = "newId";
-      mondayClient.setClientId(newId);
-      expect(mondayClient._clientId).to.equal(newId);
-    });
-
-    it("should set client id correctly (check biding)", () => {
       const newId = "newId";
       const { setClientId } = mondayClient;
+
       setClientId(newId);
+
       expect(mondayClient._clientId).to.equal(newId);
     });
 
     it("should set the api token correctly", () => {
       const newToken = "new toekn";
-      mondayClient.setToken(newToken);
+      const { setToken } = mondayClient;
+
+      setToken(newToken);
+
       expect(mondayClient._apiToken).to.equal(newToken);
     });
 
-    it("should set the api token correctly (check bindings)", () => {
-      const newToken = "new toekn";
+    it("should set the version correctly", () => {
+      const newVersion = "2023-01";
+      const { setApiVersion } = mondayClient;
 
-      const { setToken } = mondayClient;
-      setToken(newToken);
-      expect(mondayClient._apiToken).to.equal(newToken);
+      setApiVersion(newVersion);
+
+      expect(mondayClient._apiVersion).to.eq(newVersion);
     });
   });
 

package/src/client.js

@@ -10,11 +10,13 @@ class MondayClientSdk {
   constructor(options = {}) {
     this._clientId = options.clientId;
     this._apiToken = options.apiToken;
+    this._apiVersion = options.apiVersion;
 
     this.listeners = {};
 
     this.setClientId = this.setClientId.bind(this);
     this.setToken = this.setToken.bind(this);
+    this.setApiVersion = this.setApiVersion.bind(this);
     this.api = this.api.bind(this);
     this.listen = this.listen.bind(this);
     this.get = this.get.bind(this);
@@ -46,11 +48,17 @@ class MondayClientSdk {
     this._apiToken = token;
   }
 
+  setApiVersion(apiVersion) {
+    this._apiVersion = apiVersion;
+  }
+
   api(query, options = {}) {
     const params = { query, variables: options.variables };
     const token = options.token || this._apiToken;
+    const apiVersion = options.apiVersion || this._apiVersion;
+
     if (token) {
-      return mondayApiClient.execute(params, token);
+      return mondayApiClient.execute(params, token, { apiVersion });
     } else {
       return new Promise((resolve, reject) => {
         this._localApi("api", { params })

package/src/monday-api-client/monday-api-client-test.js

@@ -34,6 +34,17 @@ describe("mondayApiClient", () => {
     });
   });
 
+  it("should call node fetch with the version header", async () => {
+    const apiVersion = "2023-01";
+    await mondayApiClient.execute("query { boards { id, name }}", "api_token", { apiVersion });
+    assert.calledOnce(nodeFetchStub);
+    assert.calledWithExactly(nodeFetchStub, "https://api.monday.com/v2", {
+      body: '"query { boards { id, name }}"',
+      headers: { Authorization: "api_token", "Content-Type": "application/json", "API-Version": apiVersion },
+      method: "POST"
+    });
+  });
+
   it(`should throw ${mondayApiClient.TOKEN_IS_REQUIRED_ERROR}`, async () => {
     let errorMessage;
     try {

package/src/monday-api-client/monday-api-client.js

@@ -11,7 +11,8 @@ function apiRequest(url, data, token, options = {}) {
     body: JSON.stringify(data || {}),
     headers: {
       Authorization: token,
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      ...(options.apiVersion ? { "API-Version": options.apiVersion } : {})
     }
   });
 }

package/src/server-test.js

@@ -17,6 +17,11 @@ describe("server sdk", () => {
       const serverSdk = initServerSdk({ token: "sometoken123" });
       expect(serverSdk._token).to.eq("sometoken123");
     });
+
+    it("should be able to init serverSdk with API version", () => {
+      const serverSdk = initServerSdk({ apiVersion: "2023-01" });
+      expect(serverSdk._apiVersion).to.eq("2023-01");
+    });
   });
 
   describe("setToken", () => {
@@ -36,6 +41,18 @@ describe("server sdk", () => {
     });
   });
 
+  describe("setApiVersion", () => {
+    it("should be able to set the version", () => {
+      const serverSdk = initServerSdk();
+      expect(serverSdk._apiVersion).to.eq(undefined);
+
+      const { setApiVersion } = serverSdk;
+      setApiVersion("2023-01");
+
+      expect(serverSdk._apiVersion).to.eq("2023-01");
+    });
+  });
+
   describe("api", () => {
     let mondayApiClientExecuteStub;
 
@@ -60,7 +77,8 @@ describe("server sdk", () => {
       assert.calledWithExactly(
         mondayApiClientExecuteStub,
         { query: "query { boards { id, name }}", variables: undefined },
-        "api_token"
+        "api_token",
+        { apiVersion: undefined }
       );
     });
 
@@ -101,7 +119,8 @@ describe("server sdk", () => {
       `,
           variables: { columnValues: { numbers: 3 }, pulseName: "new pulse" }
         },
-        "api_token"
+        "api_token",
+        { apiVersion: undefined }
       );
     });
 
@@ -120,7 +139,47 @@ describe("server sdk", () => {
       assert.calledWithExactly(
         mondayApiClientExecuteStub,
         { query: "query { boards { id, name }}", variables: undefined },
-        "api_token_2"
+        "api_token_2",
+        { apiVersion: undefined }
+      );
+    });
+
+    it("should provide version to mondayApi", async () => {
+      const serverSdk = initServerSdk({ token: "api_token", apiVersion: "2023-01" });
+      serverSdk.setApiVersion("2023-04");
+      await serverSdk.api("query { boards { id, name }}");
+      assert.calledOnce(mondayApiClientExecuteStub);
+      assert.calledWithExactly(
+        mondayApiClientExecuteStub,
+        { query: "query { boards { id, name }}", variables: undefined },
+        "api_token",
+        { apiVersion: "2023-04" }
+      );
+    });
+
+    it("should prefer version from method options when calling mondayApi", async () => {
+      const serverSdk = initServerSdk({ token: "api_token", apiVersion: "2023-01" });
+      serverSdk.setApiVersion("2023-04");
+      await serverSdk.api("query { boards { id, name }}", { apiVersion: "2023-07" });
+      assert.calledOnce(mondayApiClientExecuteStub);
+      assert.calledWithExactly(
+        mondayApiClientExecuteStub,
+        { query: "query { boards { id, name }}", variables: undefined },
+        "api_token",
+        { apiVersion: "2023-07" }
+      );
+    });
+
+    it("should call to mondayApi prefer version from options", async () => {
+      const serverSdk = initServerSdk({ token: "api_token", apiVersion: "2023-01" });
+      serverSdk.setApiVersion("2023-04");
+      await serverSdk.api("query { boards { id, name }}", { apiVersion: "2023-07" });
+      assert.calledOnce(mondayApiClientExecuteStub);
+      assert.calledWithExactly(
+        mondayApiClientExecuteStub,
+        { query: "query { boards { id, name }}", variables: undefined },
+        "api_token",
+        { apiVersion: "2023-07" }
       );
     });
 

package/src/server.js

@@ -6,8 +6,10 @@ const TOKEN_MISSING_ERROR = "Should send 'token' as an option or call mondaySdk.
 class MondayServerSdk {
   constructor(options = {}) {
     this._token = options.token;
+    this._apiVersion = options.apiVersion;
 
     this.setToken = this.setToken.bind(this);
+    this.setApiVersion = this.setApiVersion.bind(this);
     this.api = this.api.bind(this);
   }
 
@@ -15,13 +17,18 @@ class MondayServerSdk {
     this._token = token;
   }
 
+  setApiVersion(apiVersion) {
+    this._apiVersion = apiVersion;
+  }
+
   async api(query, options = {}) {
     const params = { query, variables: options.variables };
     const token = options.token || this._token;
+    const apiVersion = options.apiVersion || this._apiVersion;
 
     if (!token) throw new Error(TOKEN_MISSING_ERROR);
 
-    return await mondayApiClient.execute(params, token);
+    return await mondayApiClient.execute(params, token, { apiVersion });
   }
 
   oauthToken(code, clientId, clientSecret) {

package/types/client-api.interface.ts

@@ -9,6 +9,12 @@ interface APIOptions {
      * An object containing GraphQL query variables
      */
     variables?: object | undefined;
+
+    /**
+     * A string specifying which version of the API should be used
+     * If not set, will use the default version (stable)
+     */
+    apiVersion?: string;
 }
 
 interface OAuthOptions {

package/types/client-data.interface.ts

@@ -3,15 +3,42 @@ type SubscribableEvents = 'context' | 'settings' | 'itemIds' | 'events';
 type SettableTypes = 'settings';
 
 interface GetResponse {
-    value: any;
-    version: any;
+    data: {
+        success: boolean;
+        value: any;
+        version?: any;
+    };
+    errorMessage?: string | undefined;
+    method: string;
+    requestId: string;
+    type?: string | undefined;
+}
+
+interface DeleteResponse {
+    data: {
+        success: boolean;
+        value: any; 
+    };
+    errorMessage?: string | undefined;
+    method: string;
+    requestId: string;
+    type?: string | undefined;
 }
 
 interface SetResponse {
-    success: boolean;
-    reason?: string | undefined;
+    data: {
+        success: boolean;
+        version: string;
+        reason?: string | undefined;
+        error?: string | undefined;
+    };
+    errorMessage?: string | undefined;
+    requestId: string;
+    method: string;
+    type?: string | undefined;
 }
 
+
 export interface ClientData {
     /**
      * Used for retrieving data from the parent monday.com application where your app is currently running.
@@ -62,14 +89,21 @@ export interface ClientData {
              * Returns a stored value from the database under `key`
              * @param key
              */
-            getItem(key: string): Promise<{ data: GetResponse }>;
+            getItem(key: string): Promise<GetResponse>;
+
+            /**
+             * Deletes a stored value from the database under `key`
+             * @param key
+             */
+            deleteItem(key: string): Promise<DeleteResponse>;
 
             /**
              * Stores `value` under `key` in the database
              * @param key
              * @param value
+             * @param options
              */
-            setItem(key: string, value: any): Promise<SetResponse>;
+            setItem(key: string, value: any, options?: { previous_version?: string }): Promise<SetResponse>;
         };
     };    
-}
+}

package/types/index.d.ts

@@ -10,7 +10,7 @@ type MondayClientSdk = ClientData & ClientExecute & ClientApi;
 interface MondayServerSdk {
     setToken(token: string): void;
 
-    api(query: string, options?: Partial<{ token: string, variables: object } >): Promise<any>;
+    api(query: string, options?: Partial<{ token: string, variables: object, apiVersion: string } >): Promise<any>;
 
     oauthToken(code: string, clientId: string, clientSecret: string): Promise<any>;
 }