@adobe/helix-google-support 2.2.16 → 2.3.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [2.3.0](https://github.com/adobe/helix-google-support/compare/v2.2.17...v2.3.0) (2023-08-31)
+
+
+### Features
+
+* sheet create/update/delete functionalities ([a6b8e65](https://github.com/adobe/helix-google-support/commit/a6b8e65280e964201e6a3be2e24a681a3e3cd2f8))
+
+## [2.2.17](https://github.com/adobe/helix-google-support/compare/v2.2.16...v2.2.17) (2023-08-28)
+
+
+### Bug Fixes
+
+* **deps:** update dependency @adobe/helix-onedrive-support to v10.4.0 ([24f3d53](https://github.com/adobe/helix-google-support/commit/24f3d53d9bb449e8e06774b38c4cfb0ce5fd0bbc))
+
 ## [2.2.16](https://github.com/adobe/helix-google-support/compare/v2.2.15...v2.2.16) (2023-08-22)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-google-support",
-  "version": "2.2.16",
+  "version": "2.3.0",
   "description": "Helix Google Support",
   "main": "src/index.js",
   "type": "module",
@@ -30,8 +30,8 @@
     "reporter-options": "configFile=.mocha-multi.json"
   },
   "dependencies": {
-    "@adobe/helix-onedrive-support": "10.3.7",
-    "googleapis": "126.0.0",
+    "@adobe/helix-onedrive-support": "10.4.0",
+    "googleapis": "126.0.1",
     "lru-cache": "10.0.1"
   },
   "devDependencies": {
@@ -40,16 +40,16 @@
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/git": "10.0.1",
     "c8": "8.0.1",
-    "eslint": "8.47.0",
+    "eslint": "8.48.0",
     "eslint-plugin-header": "3.1.1",
     "eslint-plugin-import": "2.28.1",
     "husky": "8.0.3",
     "junit-report-builder": "3.0.1",
-    "lint-staged": "14.0.0",
+    "lint-staged": "14.0.1",
     "mocha": "10.2.0",
     "mocha-multi-reporters": "1.5.1",
     "nock": "13.3.3",
-    "semantic-release": "21.0.7"
+    "semantic-release": "21.1.1"
   },
   "lint-staged": {
     "*.js": "eslint",

package/src/GoogleClient.d.ts

@@ -156,4 +156,35 @@ declare class GoogleClient {
    * @returns {Promise<object>|null} The document or {@code null} if the document does not exist
    */
   getDocumentFromPath(parentId:string, path:string, noRetry:boolean):Promise<object>;
+
+   /**
+   *  create a new file in the given parent folder with the given name and mimetype
+   *  @param {string} parentId
+   * @param {string} name
+   * @param {string} mimeType either {@link GoogleClient.TYPE_DOCUMENT} or {@link GoogleClient.TYPE_SPREADSHEET}
+   * @returns {Promise<object>} file object
+   */
+   createBlankDocOrSheet(parentId:string, name:string, mimeType:string):Promise<object>;
+
+
+   /**
+    * 
+    * @param {string} spreadsheetId 
+    * @param {string} sheetName 
+    * @param {object} worksheetData 
+    * 
+    * @returns {Promise<string>} sheetId or {@code null}
+    */
+   updateSheet(spreadsheetId:string, sheetName:string, worksheetData:object, create:boolean):Promise<string>;
+
+
+   /**
+    * 
+    * @param spreadsheetId 
+    * @param sheetName sheetName to delete in the spreadsheet
+    * 
+    * @returns {Promise<void>}
+    */
+   deleteSheet(spreadsheetId:string, sheetName:string):Promise<void>;
+
 }

package/src/GoogleClient.js

@@ -562,6 +562,153 @@ export class GoogleClient {
       }
     }
   }
+
+  /**
+   *
+   * @param {string} parentId
+   * @param {string} name
+   * @param {string} mimeType one of GoogleClient.TYPE_DOCUMENT or GoogleClient.TYPE_SPREADSHEET
+   * @returns {Promise<object>} file object
+   */
+  async createBlankDocOrSheet(parentId, name, mimeType) {
+    try {
+      if (
+        mimeType !== GoogleClient.TYPE_DOCUMENT
+        && mimeType !== GoogleClient.TYPE_SPREADSHEET
+      ) {
+        throw new Error(`Invalid mimeType ${mimeType}`);
+      }
+      const requestBody = {
+        name,
+        mimeType,
+      };
+
+      if (parentId) {
+        requestBody.parents = [parentId];
+      }
+
+      const response = await this.drive.files.create({
+        requestBody,
+      });
+
+      return response.data;
+    } catch (e) {
+      this.log.info(`Error creating file ${name}`);
+      throw e;
+    }
+  }
+
+  /**
+   *
+   * @param {string} spreadsheetId
+   * @param {string} sheetName
+   * @param {object} worksheetData
+   * @param {boolean} create - Indicates whether to create the sheet if it doesn't exist
+   * @returns {Promise<string>} sheetId or {@code null}
+   */
+  async updateSheet(spreadsheetId, sheetName, worksheetData, create = true) {
+    try {
+      const sheets = google.sheets({
+        version: 'v4',
+        auth: this.auth,
+      });
+
+      // Check if the sheet already exists
+      const spreadsheetInfo = await sheets.spreadsheets.get({ spreadsheetId });
+
+      const sheetExists = spreadsheetInfo.data.sheets.some(
+        (sheet) => sheet.properties.title === sheetName,
+      );
+
+      let sheetId;
+
+      if (!sheetExists) {
+        // Create a new sheet if it doesn't exist and the 'create' flag is true
+        if (!create) {
+          this.log.info('Sheet does not exists and not creating, nothing to do.');
+          return null;
+        }
+
+        const createResponse = await sheets.spreadsheets.batchUpdate({
+          spreadsheetId,
+          requestBody: {
+            requests: [
+              {
+                addSheet: {
+                  properties: {
+                    title: sheetName,
+                  },
+                },
+              },
+            ],
+          },
+        });
+
+        // Get the sheet ID of the newly created sheet
+        sheetId = createResponse.data.replies[0].addSheet.properties.sheetId;
+      } else {
+        // Get the sheet ID of the existing sheet
+        const sheetInfo = spreadsheetInfo.data.sheets.find(
+          (sheet) => sheet.properties.title === sheetName,
+        );
+        sheetId = sheetInfo.properties.sheetId;
+      }
+
+      if (Array.isArray(worksheetData) && Array.isArray(worksheetData[0])) {
+        await sheets.spreadsheets.values.update({
+          spreadsheetId,
+          range: `'${sheetName}'`,
+          valueInputOption: 'RAW',
+          resource: {
+            values: worksheetData,
+          },
+        });
+      }
+      return sheetId;
+    } catch (error) {
+      this.log.info(`Error in updating sheet: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   *
+   * @param {string} spreadsheetId
+   * @param {string} sheetName
+   *
+   * @returns void
+   */
+  async deleteGSheet(spreadsheetId, sheetName) {
+    try {
+      const sheets = google.sheets({
+        version: 'v4',
+        auth: this.auth,
+      });
+
+      const sheetsResponse = await sheets.spreadsheets.get({
+        spreadsheetId,
+        ranges: [sheetName],
+        fields: 'sheets.properties.sheetId',
+      });
+
+      const existingSheetId = sheetsResponse.data.sheets[0].properties.sheetId;
+      await sheets.spreadsheets.batchUpdate({
+        spreadsheetId,
+        requestBody: {
+          requests: [
+            {
+              deleteSheet: {
+                sheetId: existingSheetId,
+              },
+            },
+          ],
+        },
+      });
+    } catch (error) {
+      this.log.info(`Error deleting sheet from spreadsheet: ${error.message}`);
+      throw error;
+    }
+  }
 }
 
 Object.assign(GoogleClient, {