@adobe/helix-google-support 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.2.0](https://github.com/adobe/helix-google-support/compare/v1.1.0...v1.2.0) (2022-04-28)
+
+
+### Features
+
+* add get file|doc from path ([#9](https://github.com/adobe/helix-google-support/issues/9)) ([4a2e927](https://github.com/adobe/helix-google-support/commit/4a2e9272f4328e936e65b7144d04e516ac602625))
+
 # [1.1.0](https://github.com/adobe/helix-google-support/compare/v1.0.1...v1.1.0) (2022-04-28)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-google-support",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Helix Google Support",
   "main": "src/index.js",
   "type": "module",

package/src/GoogleClient.d.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+declare interface ICachePlugin {}
+
+declare interface DriveItemInfo {}
+
+declare interface GoogleClientOptions {
+  log:Console;
+  clientId:string;
+  clientSecret:string;
+  redirectUri:string;
+  cachePlugin?:ICachePlugin;
+}
+
+/**
+ * Google client
+ */
+declare class GoogleClient {
+  /**
+   * Sets the global item cache options. It internally creates a new LRU
+   * with the given options
+   *
+   * @param opts
+   */
+  static setItemCacheOptions(opts:object);
+
+  /**
+   * Returns a url for a google drive id.
+   * @param {string} id
+   * @returns {string}
+   */
+  static id2Url(id:string):string;
+
+  constructor(opts:GoogleClientOptions);
+
+  init():Promise<GoogleClient>;
+
+  generateAuthUrl(...args):Promise<string>;
+
+  /**
+   * Sets the credentials
+   * @param tokens
+   * @returns {Promise<void>}
+   */
+  setCredentials(tokens:object):Promise<void>;
+
+  /**
+   * Returns the token for the given code
+   * @param {string} code
+   * @returns {Promise<*>}
+   */
+  getToken(code:string):Promise<object>;
+
+  /**
+   * @param {string} parentId
+   * @param {string[]} pathSegments
+   * @param {string} parentPath
+   * @returns {Promise<DriveItemInfo[]>|null}
+   */
+  getUncachedItemsFromSegments(parentId:string, pathSegments:string[], parentPath:string):Promise<DriveItemInfo[]>;
+
+  /**
+   * @param {string} parentId
+   * @param {string} pathSegments
+   * @param {string} parentPath
+   * @returns {Promise<DriveItemInfo[]>|null}
+   */
+  getDriveItemsFromSegments(parentId:string, pathSegments:string[], parentPath:string):Promise<DriveItemInfo[]>;
+
+  /**
+   * returns the items hierarchy for the given path and root id, starting with the given path.
+   * @param {string} parentId
+   * @param {string} path
+   * @return {DriveItemInfo[]}
+   */
+  getDriveItemsFromSegments(parentId:string, path:string):Promise<DriveItemInfo[]>;
+
+  /**
+   * returns the items hierarchy for the given item, starting with the given id
+   * @param {string} fileId
+   * @param {object} roots
+   * @returns {Promise<DriveItemInfo[]>}
+   */
+  getItemsFromId(fileId:string, roots:object):Promise<DriveItemInfo[]>;
+
+  /**
+   * Returns the (cached) item for the given path or {@code null} if the item cannot be found.
+   * The item will contains a `invalidate()` method which can be used to remove it from the cache.
+   *
+   * @param {string} parentId
+   * @param {string} path
+   * @returns {Promise<DriveItemInfo>}
+   */
+  getItemFromPath(parentId:string, path:string):Promise<DriveItemInfo>;
+
+  /**
+   * Returns an (uncached) file directly via the google api
+   * @param {string} fileId
+   * @returns {string} file data
+   */
+  getFile(fileId:string):Promise<string>;
+
+  /**
+   * Fetches the file data from the give path. If the file with the internal id could not be
+   * fetched, the item cache is invalidated and the operation is retried. this is to support
+   * moved items.
+   * @param {string} parentId
+   * @param {string} path
+   * @param {boolean} noRetry {@code true} to avoid retry
+   * @returns {Promise<string>|null} The data of the file or {@code null} if the file does not exist
+   */
+  getFileFromPath(parentId:string, path:string, noRetry:boolean):Promise<string>;
+
+  /**
+   * Returns an (uncached) document directly via the google api
+   * @param {string} documentId
+   * @returns {object} document
+   */
+  getDocument(documentId:string):Promise<object>;
+
+  /**
+   * Fetches the document from the give path. If the document with the internal id could not be
+   * fetched, the item cache is invalidated and the operation is retried. this is to support
+   * moved items.
+   * @param {string} parentId
+   * @param {string} path
+   * @param {boolean} noRetry {@code true} to avoid retry
+   * @returns {Promise<object>|null} The document or {@code null} if the document does not exist
+   */
+  getDocumentFromPath(parentId:string, path:string, noRetry:boolean):Promise<object>;
+}

package/src/GoogleClient.js

@@ -150,12 +150,12 @@ export class GoogleClient {
   }
 
   /**
-   * @param {string[]} pathSegments
    * @param {string} parentId
+   * @param {string[]} pathSegments
    * @param {string} parentPath
    * @returns {Promise<DriveItemInfo[]>|null}
    */
-  async getUncachedItemsFromSegments(pathSegments, parentId, parentPath) {
+  async getUncachedItemsFromSegments(parentId, pathSegments, parentPath) {
     const { log, drive } = this;
     const name = pathSegments.shift();
     const [baseName, ext] = splitByExtension(name);
@@ -226,7 +226,7 @@ export class GoogleClient {
     const itemPath = `${parentPath}/${sanitizedName}`;
     const children = pathSegments.length
       // eslint-disable-next-line no-use-before-define
-      ? await this.getDriveItemsFromSegments(pathSegments, item.id, itemPath)
+      ? await this.getDriveItemsFromSegments(item.id, pathSegments, itemPath)
       : [];
 
     if (!children) {
@@ -250,18 +250,18 @@ export class GoogleClient {
   }
 
   /**
-   * @param {string} pathSegments
    * @param {string} parentId
+   * @param {string} pathSegments
    * @param {string} parentPath
    * @returns {Promise<DriveItemInfo[]>|null}
    */
-  async getDriveItemsFromSegments(pathSegments, parentId, parentPath) {
+  async getDriveItemsFromSegments(parentId, pathSegments, parentPath) {
     const key = getCacheKey(parentId, pathSegments);
     let items = lru.get(key);
     if (items) {
       return items;
     }
-    items = await this.getUncachedItemsFromSegments(pathSegments, parentId, parentPath);
+    items = await this.getUncachedItemsFromSegments(parentId, pathSegments, parentPath);
     if (items) {
       lru.set(key, items);
       // add invalidation function as not-enumerable to keep compatible objects
@@ -278,20 +278,20 @@ export class GoogleClient {
 
   /**
    * returns the items hierarchy for the given path and root id, starting with the given path.
-   * @param path
-   * @param rootId
+   * @param {string} parentId
+   * @param {string} path
    * @return {DriveItemInfo[]}
    */
-  async getItemsFromPath(path, rootId) {
+  async getItemsFromPath(parentId, path) {
     const segs = createPathSegments(path);
-    const result = await this.getDriveItemsFromSegments(segs, rootId, '');
+    const result = await this.getDriveItemsFromSegments(parentId, segs, '');
     if (!result) {
       return [];
     }
     return [...result, {
       name: '',
       path: '/',
-      id: rootId,
+      id: parentId,
     }];
   }
 
@@ -299,6 +299,7 @@ export class GoogleClient {
    * returns the items hierarchy for the given item, starting with the given id
    * @param {string} fileId
    * @param {object} roots
+   * @private
    * @returns {Promise<DriveItemInfo[]>}
    */
   async getItems(fileId, roots) {
@@ -366,13 +367,13 @@ export class GoogleClient {
    * Returns the (cached) item for the given path or {@code null} if the item cannot be found.
    * The item will contains a `invalidate()` method which can be used to remove it from the cache.
    *
-   * @param {string} rootId
+   * @param {string} parentId
    * @param {string} path
    * @returns {Promise<DriveItemInfo>}
    */
-  async getItemFromPath(rootId, path) {
+  async getItemFromPath(parentId, path) {
     const segs = createPathSegments(path);
-    const items = await this.getDriveItemsFromSegments(segs, rootId, '');
+    const items = await this.getDriveItemsFromSegments(parentId, segs, '');
     const item = items?.[0];
     if (!item) {
       return null;
@@ -400,6 +401,37 @@ export class GoogleClient {
     }
   }
 
+  /**
+   * Fetches the file data from the give path. If the file with the internal id could not be
+   * fetched, the item cache is invalidated and the operation is retried. this is to support
+   * moved items.
+   * @param {string} parentId
+   * @param {string} path
+   * @param {boolean} noRetry {@code true} to avoid retry
+   * @returns {Promise<string>|null} The data of the file or {@code null} if the file does not exist
+   */
+  async getFileFromPath(parentId, path, noRetry) {
+    const item = await this.getItemFromPath(parentId, path);
+    if (!item) {
+      return null;
+    }
+    try {
+      // noinspection ES6RedundantAwait (need to catch exception)
+      return await this.getFile(item.id);
+    } catch (e) {
+      if (e.statusCode === 404) {
+        if (noRetry) {
+          return null;
+        }
+        this.log.info(`file ${item.id} does not exist - invalidating cache and retry`);
+        item.invalidate();
+        return this.getFileFromPath(parentId, path, true);
+      } else {
+        throw e;
+      }
+    }
+  }
+
   /**
    * Returns an (uncached) document directly via the google api
    * @param {string} documentId
@@ -420,4 +452,35 @@ export class GoogleClient {
       throw e;
     }
   }
+
+  /**
+   * Fetches the document from the give path. If the document with the internal id could not be
+   * fetched, the item cache is invalidated and the operation is retried. this is to support
+   * moved items.
+   * @param {string} parentId
+   * @param {string} path
+   * @param {boolean} noRetry {@code true} to avoid retry
+   * @returns {Promise<object>|null} The document or {@code null} if the document does not exist
+   */
+  async getDocumentFromPath(parentId, path, noRetry) {
+    const item = await this.getItemFromPath(parentId, path);
+    if (!item) {
+      return null;
+    }
+    try {
+      // noinspection ES6RedundantAwait (need to catch exception)
+      return await this.getDocument(item.id);
+    } catch (e) {
+      if (e.statusCode === 404) {
+        if (noRetry) {
+          return null;
+        }
+        this.log.info(`document ${item.id} does not exist - invalidating cache and retry`);
+        item.invalidate();
+        return this.getDocumentFromPath(parentId, path, true);
+      } else {
+        throw e;
+      }
+    }
+  }
 }