@adobe/helix-google-support 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.1.0](https://github.com/adobe/helix-google-support/compare/v1.0.1...v1.1.0) (2022-04-28)
+
+
+### Features
+
+* add cache invalidate for drive items ([#8](https://github.com/adobe/helix-google-support/issues/8)) ([7aa2c80](https://github.com/adobe/helix-google-support/commit/7aa2c8061facb2d3c45929356c23370d83686f55))
+
 ## [1.0.1](https://github.com/adobe/helix-google-support/compare/v1.0.0...v1.0.1) (2022-04-20)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-google-support",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Helix Google Support",
   "main": "src/index.js",
   "type": "module",
@@ -40,14 +40,14 @@
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
     "@semantic-release/npm": "9.0.1",
-    "c8": "7.11.0",
+    "c8": "7.11.2",
     "codecov": "3.8.3",
-    "eslint": "8.13.0",
+    "eslint": "8.14.0",
     "eslint-plugin-header": "3.1.1",
     "eslint-plugin-import": "2.26.0",
     "husky": "7.0.4",
     "junit-report-builder": "3.0.0",
-    "lint-staged": "12.3.8",
+    "lint-staged": "12.4.0",
     "mocha": "9.2.2",
     "mocha-multi-reporters": "1.5.1",
     "nock": "13.2.4",

package/src/GoogleClient.js

@@ -9,13 +9,15 @@
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */
+import LRU from 'lru-cache';
 import { google } from 'googleapis';
 import {
   editDistance, sanitizeName, splitByExtension,
 } from '@adobe/helix-onedrive-support/utils';
 import { StatusCodeError } from '@adobe/helix-onedrive-support';
 import { GoogleTokenCache } from './GoogleTokenCache.js';
-import cache from './cache.js';
+
+let lru = new LRU({ max: 1000, ttl: 60000 });
 
 /**
  * @typedef DriveItemInfo {
@@ -39,6 +41,19 @@ function addLastModified(itemInfo, item) {
   return itemInfo;
 }
 
+function createPathSegments(path) {
+  const pathSegments = path.split('/');
+  if (!pathSegments[0]) {
+    // if path starts with '/' the first segment is empty
+    pathSegments.shift();
+  }
+  return pathSegments;
+}
+
+function getCacheKey(parentId, pathSegments) {
+  return `${parentId}:${pathSegments.join('/')}`;
+}
+
 /**
  * Google auth client
  */
@@ -50,7 +65,7 @@ export class GoogleClient {
    * @param opts
    */
   static setItemCacheOptions(opts) {
-    cache.options(opts);
+    lru = new LRU(opts);
   }
 
   /**
@@ -95,13 +110,6 @@ export class GoogleClient {
       version: 'v3',
       auth: this.auth,
     });
-
-    /**
-     * Cached version of `getUncachedItemsFromSegments`
-     */
-    this.getDriveItemsFromSegments = cache(this.getUncachedItemsFromSegments.bind(this), {
-      hash: (fn, segs, parentId) => `${parentId}:${segs.join('/')}`,
-    });
   }
 
   async init() {
@@ -142,10 +150,10 @@ export class GoogleClient {
   }
 
   /**
-   * @param {string} path
+   * @param {string[]} pathSegments
    * @param {string} parentId
    * @param {string} parentPath
-   * @returns {Promise<DriveItemInfo[]>}
+   * @returns {Promise<DriveItemInfo[]>|null}
    */
   async getUncachedItemsFromSegments(pathSegments, parentId, parentPath) {
     const { log, drive } = this;
@@ -224,16 +232,50 @@ export class GoogleClient {
     if (!children) {
       return null;
     }
-
     const pathItem = addLastModified({
       name,
       path: itemPath,
       id: item.id,
     }, item);
 
+    if (children.length) {
+      // add parent references not-enumerable to avoid deep structures during serialization
+      Object.defineProperty(children[children.length - 1], 'parent', {
+        enumerable: false,
+        value: pathItem,
+      });
+    }
+
     return [...children, pathItem];
   }
 
+  /**
+   * @param {string} pathSegments
+   * @param {string} parentId
+   * @param {string} parentPath
+   * @returns {Promise<DriveItemInfo[]>|null}
+   */
+  async getDriveItemsFromSegments(pathSegments, parentId, parentPath) {
+    const key = getCacheKey(parentId, pathSegments);
+    let items = lru.get(key);
+    if (items) {
+      return items;
+    }
+    items = await this.getUncachedItemsFromSegments(pathSegments, parentId, parentPath);
+    if (items) {
+      lru.set(key, items);
+      // add invalidation function as not-enumerable to keep compatible objects
+      Object.defineProperty(items[items.length - 1], 'invalidate', {
+        enumerable: false,
+        value() {
+          lru.delete(key);
+          this.parent?.invalidate();
+        },
+      });
+    }
+    return items;
+  }
+
   /**
    * returns the items hierarchy for the given path and root id, starting with the given path.
    * @param path
@@ -241,11 +283,7 @@ export class GoogleClient {
    * @return {DriveItemInfo[]}
    */
   async getItemsFromPath(path, rootId) {
-    const segs = path.split('/');
-    if (!segs[0]) {
-      // if path starts with '/' the first segment is empty
-      segs.shift();
-    }
+    const segs = createPathSegments(path);
     const result = await this.getDriveItemsFromSegments(segs, rootId, '');
     if (!result) {
       return [];
@@ -325,6 +363,25 @@ 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} path
+   * @returns {Promise<DriveItemInfo>}
+   */
+  async getItemFromPath(rootId, path) {
+    const segs = createPathSegments(path);
+    const items = await this.getDriveItemsFromSegments(segs, rootId, '');
+    const item = items?.[0];
+    if (!item) {
+      return null;
+    }
+    return item;
+  }
+
+  /**
+   * Returns an (uncached) file directly via the google api
    * @param {string} fileId
    * @returns {string} file data
    */
@@ -343,6 +400,11 @@ export class GoogleClient {
     }
   }
 
+  /**
+   * Returns an (uncached) document directly via the google api
+   * @param {string} documentId
+   * @returns {object} document
+   */
   async getDocument(documentId) {
     const docs = google.docs({
       version: 'v1',

package/src/cache.js

@@ -1,78 +0,0 @@
-/*
- * Copyright 2020 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.
- */
-import LRU from 'lru-cache';
-
-let lru = new LRU({ max: 1000, ttl: 60000 });
-
-/**
- * Returns a memoized version of the function `fn`.
- * @param {function} fn a function to memoize
- * @param {object} opts caching options
- * @param {function} opts.hash a hash function to build a cache key.
- * The hash function will be called with the `fn` and a list of
- * it's arguments. A good hashing function will discard irrelevant
- * arguments and join the resulting arguments
- * @param {function} opts.cacheresult a predicate function that will be called
- * with the result of the function execution. Only when this function returns
- * `true` will the result be cached. The default is that all results are
- * cached.
- * @param {function} opts.cacheerror a predicate function that will be called
- * with the error that the function execution throws. Only when this
- * function returns `true` will the error be cached. The default is that
- * errors are never cached, so that each new invocation will be uncached.
- */
-export default function cache(fn, opts = {}) {
-  const {
-    hash = (...args) => args.join(),
-    cacheresult = () => true,
-    cacheerror = () => false,
-  } = opts;
-  return async function cached(...args) {
-    const key = hash(fn, ...args);
-    const entry = lru.get(key);
-    if (entry) {
-      if (entry.err) {
-        throw entry.err;
-      }
-      return entry.ok;
-    }
-    try {
-      // invoke the function
-      const result = await fn(...args);
-      if (cacheresult(result)) {
-        // store the result under ok if permitted
-        lru.set(key, { ok: result });
-      }
-      // and return the result
-      return result;
-    } catch (err) {
-      if (cacheerror(err)) {
-        // store the error under err if permitted
-        lru.set(key, { err });
-      }
-      // and throw the error
-      throw err;
-    }
-  };
-}
-
-/**
- * Resets the QuickLRU cache with new options. Existing cache entries
- * will be cleared.
- * @param {object} opts options
- * @param {integer} opts.maxSize maximum size of the cache
- */
-cache.options = (opts) => {
-  lru = new LRU(opts);
-
-  return cache;
-};