Scope cache (#2784)

- add an option to not use cache when loading scope
- do not use scope cache by default when loading scope programmatically

Author: GiladShoham

CHANGELOG.md

@@ -7,18 +7,25 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [unreleased]
 
+- add an option to not use cache when loading scope
+- do not use scope cache by default when loading scope programmatically
+
 ## [[14.8.3] - 2020-07-01](https://github.com/teambit/bit/releases/tag/v14.8.3)
 
+### Bug Fixes
+
 - [#2780](https://github.com/teambit/bit/issues/2780) - fix dists codemod of changing one scope to another to not be triggered without --rewire flag
 - add timeout option for load core extension via api
-- wait for harmony to load if you load it many times in parallel via the api
 
-## [[14.8.3-dev.1] - 2020-06-29]
+### Internal
 
+- wait for harmony to load if you load it many times in parallel via the api
 - expose extensions declarations and instances from api
 
 ## [[14.8.2] - 2020-06-29](https://github.com/teambit/bit/releases/tag/v14.8.2)
 
+### Bug Fixes
+
 - do not show loader for internal commands
 - fix error when trying to load extension in a folder which is not a workspace or scope
 

src/api.ts

@@ -22,16 +22,28 @@ type LoadCoreExtensionsOptions = {
 };
 
 export function show(scopePath: string, id: string, opts?: Record<string, any>) {
+  // When using the API programmatically do not use the scope cache by default
+  const loadScopeFromCache = opts && opts.loadScopeFromCache !== undefined ? !!opts.loadScopeFromCache : false;
   // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-  return getScopeComponent({ scopePath, id, allVersions: opts && opts.versions }).then(({ component }) => {
-    if (Array.isArray(component)) {
-      return component.map(v => v.toObject());
+  return getScopeComponent({ scopePath, id, allVersions: opts && opts.versions, loadScopeFromCache }).then(
+    ({ component }) => {
+      if (Array.isArray(component)) {
+        return component.map(v => v.toObject());
+      }
+      return component.toObject();
     }
-    return component.toObject();
-  });
+  );
 }
-export function list(scopePath: string) {
-  return scopeList(scopePath).then(listScopeResult => listScopeResult.map(result => result.id.toString()));
+export function list(
+  scopePath: string,
+  namespacesUsingWildcards?: string,
+  opts: { loadScopeFromCache?: boolean } = {}
+) {
+  // When using the API programmatically do not use the scope cache by default
+  const loadScopeFromCache = opts && opts.loadScopeFromCache !== undefined ? !!opts.loadScopeFromCache : false;
+  return scopeList(scopePath, namespacesUsingWildcards, loadScopeFromCache).then(listScopeResult =>
+    listScopeResult.map(result => result.id.toString())
+  );
 }
 
 export async function buildOne(

src/api/consumer/lib/get-scope-component.ts

@@ -13,19 +13,21 @@ export default (async function getScopeComponent({
   allVersions,
   scopePath,
   showDependents,
-  showDependencies
+  showDependencies,
+  loadScopeFromCache
 }: {
   id: string;
   allVersions: boolean | null | undefined;
   scopePath: string | null | undefined; // used by the api (see /src/api.js)
   showDependents: boolean;
   showDependencies: boolean;
+  loadScopeFromCache: boolean;
 }): Promise<{ component: Component[] | Component }> {
   const bitId: BitId = BitId.parse(id, true); // user used --remote so we know it has a scope
 
   if (scopePath) {
     // coming from the api
-    const scope: Scope = await loadScope(scopePath);
+    const scope: Scope = await loadScope(scopePath, loadScopeFromCache);
     const component = await showComponentUsingScope(scope);
     return { component };
   }

src/api/scope/lib/scope-list.ts

@@ -2,6 +2,12 @@ import { loadScope } from '../../../scope';
 import ComponentsList from '../../../consumer/component/components-list';
 import { ListScopeResult } from '../../../consumer/component/components-list';
 
-export default function list(path: string, namespacesUsingWildcards?: string): Promise<ListScopeResult[]> {
-  return loadScope(path).then(scope => ComponentsList.listLocalScope(scope, namespacesUsingWildcards));
+export default function list(
+  path: string,
+  namespacesUsingWildcards?: string,
+  loadScopeFromCache = true
+): Promise<ListScopeResult[]> {
+  return loadScope(path, loadScopeFromCache).then(scope =>
+    ComponentsList.listLocalScope(scope, namespacesUsingWildcards)
+  );
 }

src/scope/scope-loader.ts

@@ -3,21 +3,22 @@ import Scope from './scope';
 import { resolveHomePath } from '../utils';
 import { ScopeNotFound } from './exceptions';
 
-export default function loadScope(currentPath?: string | null | undefined): Promise<Scope> {
+export default function loadScope(currentPath?: string | null | undefined, useCache = true): Promise<Scope> {
   if (!currentPath) currentPath = process.cwd();
   try {
-    return Scope.load(path.resolve(resolveHomePath(currentPath)));
+    return Scope.load(path.resolve(resolveHomePath(currentPath)), useCache);
   } catch (err) {
     return Promise.reject(err);
   }
 }
 
 export async function loadScopeIfExist(
   // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-  currentPath?: string | null | undefined = process.cwd()
+  currentPath?: string | null | undefined = process.cwd(),
+  useCache = true
 ): Promise<Scope | undefined> {
   try {
-    return await loadScope(currentPath);
+    return await loadScope(currentPath, useCache);
   } catch (err) {
     if (err instanceof ScopeNotFound) {
       return undefined;

src/scope/scope.ts

@@ -790,25 +790,27 @@ export default class Scope {
     Scope.scopeCache = {};
   }
 
-  static async load(absPath: string): Promise<Scope> {
+  static async load(absPath: string, useCache = true): Promise<Scope> {
     let scopePath = propogateUntil(absPath);
     if (!scopePath) throw new ScopeNotFound(absPath);
     if (fs.existsSync(pathLib.join(scopePath, BIT_HIDDEN_DIR))) {
       scopePath = pathLib.join(scopePath, BIT_HIDDEN_DIR);
     }
-    if (!Scope.scopeCache[scopePath]) {
-      const scopeJsonPath = getScopeJsonPath(scopePath);
-      const scopeJsonExist = fs.existsSync(scopeJsonPath);
-      let scopeJson;
-      if (scopeJsonExist) {
-        scopeJson = await ScopeJson.loadFromFile(scopeJsonPath);
-      } else {
-        scopeJson = Scope.ensureScopeJson(scopePath);
-      }
-      const objects = await Repository.load({ scopePath, scopeJson });
-      const scope = new Scope({ path: scopePath, scopeJson, objects });
-      Scope.scopeCache[scopePath] = scope;
+    if (useCache && Scope.scopeCache[scopePath]) {
+      logger.info(`taking scope at ${scopePath} from cache`);
+      return Scope.scopeCache[scopePath];
+    }
+    const scopeJsonPath = getScopeJsonPath(scopePath);
+    const scopeJsonExist = fs.existsSync(scopeJsonPath);
+    let scopeJson;
+    if (scopeJsonExist) {
+      scopeJson = await ScopeJson.loadFromFile(scopeJsonPath);
+    } else {
+      scopeJson = Scope.ensureScopeJson(scopePath);
     }
-    return Scope.scopeCache[scopePath];
+    const objects = await Repository.load({ scopePath, scopeJson });
+    const scope = new Scope({ path: scopePath, scopeJson, objects });
+    Scope.scopeCache[scopePath] = scope;
+    return scope;
   }
 }