@tolgee/core 5.0.0-rc.9be0f0e.0 → 5.0.0

package/src/Controller/Cache/Cache.ts

@@ -1,22 +1,26 @@
 import {
-  CacheAsyncRequests,
   CacheDescriptor,
   CacheDescriptorInternal,
   CacheDescriptorWithKey,
-  EventEmitterType,
-  FallbackNSTranslation,
-  Options,
+  NsFallback,
   TranslationsFlat,
   TranslationValue,
   TreeTranslationsData,
   BackendGetRecord,
   BackendGetDevRecord,
 } from '../../types';
-import { getFallbackArray } from '../State/helpers';
+import { getFallbackArray, unique } from '../../helpers';
+import { EventEmitterInstance } from '../Events/EventEmitter';
+import { TolgeeStaticData } from '../State/initState';
 import { ValueObserverInstance } from '../ValueObserver';
 
 import { decodeCacheKey, encodeCacheKey, flattenTranslations } from './helpers';
 
+type CacheAsyncRequests = Map<
+  string,
+  Promise<TreeTranslationsData | undefined> | undefined
+>;
+
 type CacheRecord = {
   version: number;
   data: TranslationsFlat;
@@ -25,7 +29,7 @@ type CacheRecord = {
 type StateCache = Map<string, CacheRecord>;
 
 export const Cache = (
-  onCacheChange: EventEmitterType<CacheDescriptorWithKey>,
+  onCacheChange: EventEmitterInstance<CacheDescriptorWithKey>,
   backendGetRecord: BackendGetRecord,
   backendGetDevRecord: BackendGetDevRecord,
   withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal,
@@ -35,10 +39,10 @@ export const Cache = (
 ) => {
   const asyncRequests: CacheAsyncRequests = new Map();
   const cache: StateCache = new Map();
-  let staticData: NonNullable<Options['staticData']> = {};
+  let staticData: NonNullable<TolgeeStaticData> = {};
   let version = 0;
 
-  function addStaticData(data: Options['staticData']) {
+  function addStaticData(data: TolgeeStaticData | undefined) {
     if (data) {
       staticData = { ...staticData, ...data };
       Object.entries(data).forEach(([key, value]) => {
@@ -86,8 +90,8 @@ export const Cache = (
     return Boolean(record);
   }
 
-  function getRecord(descriptor: CacheDescriptorInternal) {
-    return cache.get(encodeCacheKey(descriptor))?.data;
+  function getRecord(descriptor: CacheDescriptor) {
+    return cache.get(encodeCacheKey(withDefaultNs(descriptor)))?.data;
   }
 
   function getTranslation(descriptor: CacheDescriptorInternal, key: string) {
@@ -105,11 +109,11 @@ export const Cache = (
           .get(encodeCacheKey({ language, namespace }))
           ?.data.get(key);
         if (value !== undefined && value !== null) {
-          return namespace;
+          return [namespace];
         }
       }
     }
-    return Array.from(new Set(namespaces));
+    return unique(namespaces);
   }
 
   function getTranslationFallback(
@@ -140,11 +144,7 @@ export const Cache = (
     onCacheChange.emit({ ...descriptor, key });
   }
 
-  function clear() {
-    cache.clear();
-  }
-
-  function isFetching(ns?: FallbackNSTranslation) {
+  function isFetching(ns?: NsFallback) {
     if (isInitialLoading()) {
       return true;
     }
@@ -160,7 +160,7 @@ export const Cache = (
     );
   }
 
-  function isLoading(language: string | undefined, ns?: FallbackNSTranslation) {
+  function isLoading(language: string | undefined, ns?: NsFallback) {
     const namespaces = getFallbackArray(ns);
 
     return Boolean(
@@ -178,7 +178,10 @@ export const Cache = (
     );
   }
 
-  function fetchNormal(keyObject: CacheDescriptorInternal) {
+  /**
+   * Fetches production data
+   */
+  function fetchProd(keyObject: CacheDescriptorInternal) {
     let dataPromise = undefined as
       | Promise<TreeTranslationsData | undefined>
       | undefined;
@@ -186,8 +189,6 @@ export const Cache = (
       const staticDataValue = staticData[encodeCacheKey(keyObject)];
       if (typeof staticDataValue === 'function') {
         dataPromise = staticDataValue();
-      } else if (staticDataValue) {
-        dataPromise = Promise.resolve(staticDataValue);
       }
     }
 
@@ -195,10 +196,6 @@ export const Cache = (
       dataPromise = backendGetRecord(keyObject);
     }
 
-    if (!dataPromise) {
-      // return empty data, so we know it has already been attempted to fetch
-      dataPromise = Promise.resolve({});
-    }
     return dataPromise;
   }
 
@@ -210,13 +207,13 @@ export const Cache = (
       dataPromise = backendGetDevRecord(keyObject)?.catch(() => {
         // eslint-disable-next-line no-console
         console.warn(`Tolgee: Failed to fetch data from dev backend`);
-        // fallback to normal fetch if dev fails
-        return fetchNormal(keyObject);
+        // fallback to prod fetch if dev fails
+        return fetchProd(keyObject);
       });
     }
 
     if (!dataPromise) {
-      dataPromise = fetchNormal(keyObject);
+      dataPromise = fetchProd(keyObject);
     }
 
     return dataPromise;
@@ -236,7 +233,8 @@ export const Cache = (
           cacheKey,
         };
       }
-      const dataPromise = fetchData(keyObject, isDev);
+      const dataPromise =
+        fetchData(keyObject, isDev) || Promise.resolve(undefined);
       asyncRequests.set(cacheKey, dataPromise);
       return {
         new: true,
@@ -260,6 +258,9 @@ export const Cache = (
         const data = results[i];
         if (data) {
           addRecord(value.keyObject, data);
+        } else if (!getRecord(value.keyObject)) {
+          // if no data exist, put empty object
+          addRecord(value.keyObject, {});
         }
       }
     });
@@ -292,9 +293,8 @@ export const Cache = (
     isFetching,
     isLoading,
     loadRecords,
-    clear,
     getAllRecords,
   });
 };
 
-export type CacheType = ReturnType<typeof Cache>;
+export type CacheInstance = ReturnType<typeof Cache>;

package/src/Controller/Cache/helpers.ts

@@ -10,11 +10,9 @@ export const flattenTranslations = (
       return;
     }
     if (typeof value === 'object') {
-      Object.entries(flattenTranslations(value)).forEach(
-        ([flatKey, flatValue]) => {
-          result.set(key + '.' + flatKey, flatValue);
-        }
-      );
+      flattenTranslations(value).forEach((flatValue, flatKey) => {
+        result.set(key + '.' + flatKey, flatValue);
+      });
       return;
     }
     result.set(key, value as string);
@@ -23,7 +21,9 @@ export const flattenTranslations = (
 };
 
 export const decodeCacheKey = (key: string): CacheDescriptorInternal => {
-  const [firstPart, secondPart] = key.split(':');
+  const [firstPart, ...rest] = key.split(':');
+  // if namespaces contains ":" it won't get lost
+  const secondPart = rest.join(':');
   return { language: firstPart, namespace: secondPart || '' };
 };
 

package/src/Controller/Controller.ts

@@ -1,25 +1,26 @@
-import type { EventServiceType } from '../Events/Events';
+import { Events } from './Events/Events';
 import {
   CacheDescriptor,
-  FallbackNSTranslation,
-  Options,
+  NsFallback,
+  TolgeeOptions,
   TFnType,
-  TranslatePropsInternal,
+  NsType,
+  KeyAndNamespacesInternal,
 } from '../types';
 import { Cache } from './Cache/Cache';
-import { getFallbackArray } from './State/helpers';
-import { PluginService } from './Plugins/Plugins';
+import { getFallbackArray } from '../helpers';
+import { Plugins } from './Plugins/Plugins';
 import { ValueObserver } from './ValueObserver';
 import { State } from './State/State';
 import { isPromise, missingOptionError, valueOrPromise } from '../helpers';
-import { getTranslateParams } from '../TranslateParams';
+import { getTranslateProps } from '../TranslateParams';
 
 type StateServiceProps = {
-  events: EventServiceType;
-  options?: Partial<Options>;
+  options?: Partial<TolgeeOptions>;
 };
 
-export const Controller = ({ events, options }: StateServiceProps) => {
+export const Controller = ({ options }: StateServiceProps) => {
+  const events = Events(getFallbackNs, getDefaultNs);
   const fetchingObserver = ValueObserver<boolean>(
     false,
     () => cache.isFetching(),
@@ -37,7 +38,7 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     events.onRunningChange
   );
 
-  const pluginService = PluginService(
+  const pluginService = Plugins(
     state.getLanguage,
     state.getInitialOptions,
     state.getAvailableLanguages,
@@ -56,24 +57,38 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     loadingObserver
   );
 
-  state.init(options);
-  cache.addStaticData(state.getInitialOptions().staticData);
-  if (isDev()) {
-    cache.invalidate();
+  if (options) {
+    init(options);
   }
 
-  events.onKeyUpdate.listen(() => {
+  events.onUpdate.listen(() => {
     if (state.isRunning()) {
       pluginService.retranslate();
     }
   });
 
-  const t: TFnType = (...args) => {
-    // @ts-ignore
-    const params = getTranslateParams(...args);
-    const translation = getTranslation(params);
-    return pluginService.formatTranslation({ ...params, translation });
-  };
+  function getFallbackNs() {
+    return state.getFallbackNs();
+  }
+
+  function getDefaultNs(ns?: NsType) {
+    return state.getDefaultNs(ns);
+  }
+
+  // gets all namespaces where translation could be located
+  // takes (ns|default, fallback ns)
+  function getDefaultAndFallbackNs(ns?: NsType) {
+    return [...getFallbackArray(getDefaultNs(ns)), ...getFallbackNs()];
+  }
+
+  // gets all namespaces which need to be loaded
+  // takes (ns|default, initial ns, fallback ns, active ns)
+  function getRequiredNamespaces(ns: NsFallback) {
+    return [
+      ...getFallbackArray(ns || getDefaultNs()),
+      ...state.getRequiredNamespaces(),
+    ];
+  }
 
   function changeTranslation(
     descriptor: CacheDescriptor,
@@ -90,22 +105,22 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     };
   }
 
-  function init(options: Partial<Options>) {
+  function init(options: Partial<TolgeeOptions>) {
     state.init(options);
     cache.addStaticData(state.getInitialOptions().staticData);
   }
 
-  function isLoading(ns?: FallbackNSTranslation) {
+  function isLoading(ns?: NsFallback) {
     return cache.isLoading(state.getLanguage()!, ns);
   }
 
   function isDev() {
     return Boolean(
-      state.getInitialOptions().apiKey && pluginService.getDevBackend()
+      state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl
     );
   }
 
-  async function addActiveNs(ns: FallbackNSTranslation, forget?: boolean) {
+  async function addActiveNs(ns: NsFallback, forget?: boolean) {
     if (!forget) {
       state.addActiveNs(ns);
     }
@@ -114,10 +129,9 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     }
   }
 
-  function getRequiredRecords(lang?: string, ns?: FallbackNSTranslation) {
+  function getRequiredRecords(lang?: string, ns?: NsFallback) {
     const languages = state.getFallbackLangs(lang);
-    const namespaces =
-      ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+    const namespaces = getRequiredNamespaces(ns);
     const result: CacheDescriptor[] = [];
     languages.forEach((language) => {
       namespaces.forEach((namespace) => {
@@ -129,14 +143,13 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     return result;
   }
 
-  function isLoaded(ns?: FallbackNSTranslation) {
+  function isLoaded(ns?: NsFallback) {
     const language = state.getLanguage();
     if (!language) {
       return false;
     }
     const languages = state.getFallbackLangs(language);
-    const namespaces =
-      ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+    const namespaces = getRequiredNamespaces(ns);
     const result: CacheDescriptor[] = [];
     languages.forEach((language) => {
       namespaces.forEach((namespace) => {
@@ -148,7 +161,7 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     return result.length === 0;
   }
 
-  function loadRequiredRecords(lang?: string, ns?: FallbackNSTranslation) {
+  function loadRequiredRecords(lang?: string, ns?: NsFallback) {
     const descriptors = getRequiredRecords(lang, ns);
     if (descriptors.length) {
       return valueOrPromise(loadRecords(descriptors), () => {});
@@ -176,24 +189,14 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     }
   }
 
-  function getTranslationNs({
-    key,
-    ns,
-  }: Pick<TranslatePropsInternal, 'key' | 'ns'>) {
-    const namespaces = ns
-      ? getFallbackArray(ns)
-      : state.getFallbackNamespaces();
+  function getTranslationNs({ key, ns }: KeyAndNamespacesInternal) {
     const languages = state.getFallbackLangs();
+    const namespaces = getDefaultAndFallbackNs(ns);
     return cache.getTranslationNs(namespaces, languages, key);
   }
 
-  function getTranslation({
-    key,
-    ns,
-  }: Pick<TranslatePropsInternal, 'key' | 'ns'>) {
-    const namespaces = ns
-      ? getFallbackArray(ns)
-      : state.getFallbackNamespaces();
+  function getTranslation({ key, ns }: KeyAndNamespacesInternal) {
+    const namespaces = getDefaultAndFallbackNs(ns);
     const languages = state.getFallbackLangs();
     return cache.getTranslationFallback(namespaces, languages, key);
   }
@@ -201,7 +204,6 @@ export const Controller = ({ events, options }: StateServiceProps) => {
   function loadInitial() {
     const data = valueOrPromise(initializeLanguage(), () => {
       // fail if there is no language
-      state.getLanguageOrFail();
       return loadRequiredRecords();
     });
 
@@ -245,8 +247,27 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     return cache.loadRecords(descriptors, isDev());
   }
 
+  const checkCorrectConfiguration = () => {
+    const languageComputable =
+      pluginService.getLanguageDetector() || pluginService.getLanguageStorage();
+    if (languageComputable) {
+      const availableLanguages = state.getAvailableLanguages();
+      if (!availableLanguages) {
+        throw new Error(missingOptionError('availableLanguages'));
+      }
+    }
+    if (!state.getLanguage() && !state.getInitialOptions().defaultLanguage) {
+      if (languageComputable) {
+        throw new Error(missingOptionError('defaultLanguage'));
+      } else {
+        throw new Error(missingOptionError('language'));
+      }
+    }
+  };
+
   function run() {
     let result: Promise<void> | undefined = undefined;
+    checkCorrectConfiguration();
     if (!state.isRunning()) {
       if (isDev()) {
         cache.invalidate();
@@ -265,7 +286,15 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     }
   }
 
+  const t: TFnType = (...args) => {
+    // @ts-ignore
+    const params = getTranslateProps(...args);
+    const translation = getTranslation(params);
+    return pluginService.formatTranslation({ ...params, translation });
+  };
+
   return Object.freeze({
+    ...events,
     ...state,
     ...pluginService,
     ...cache,
@@ -274,7 +303,6 @@ export const Controller = ({ events, options }: StateServiceProps) => {
     getTranslation,
     changeTranslation,
     addActiveNs,
-    loadRequiredRecords,
     loadRecords,
     loadRecord,
     isLoading,
@@ -286,4 +314,4 @@ export const Controller = ({ events, options }: StateServiceProps) => {
   });
 };
 
-export type StateServiceType = ReturnType<typeof Controller>;
+export type ControllerInstance = ReturnType<typeof Controller>;

package/src/Controller/Events/EventEmitter.ts

@@ -0,0 +1,34 @@
+import { Subscription, Listener } from '../../types';
+
+export const EventEmitter = <T>(
+  isActive: () => boolean
+): EventEmitterInstance<T> => {
+  let handlers: Listener<T>[] = [];
+
+  const listen = (handler: Listener<T>): Subscription => {
+    const handlerWrapper: Listener<T> = (e) => {
+      handler(e);
+    };
+
+    handlers.push(handlerWrapper);
+
+    return {
+      unsubscribe: () => {
+        handlers = handlers.filter((i) => handlerWrapper !== i);
+      },
+    };
+  };
+
+  const emit = (data: T) => {
+    if (isActive()) {
+      handlers.forEach((handler) => handler({ value: data }));
+    }
+  };
+
+  return Object.freeze({ listen, emit });
+};
+
+export type EventEmitterInstance<T> = {
+  readonly listen: (handler: Listener<T>) => Subscription;
+  readonly emit: (data: T) => void;
+};

package/src/Controller/Events/EventEmitterSelective.test.ts

@@ -0,0 +1,110 @@
+import { EventEmitterSelective } from './EventEmitterSelective';
+
+describe('event emitter selective', () => {
+  it('handles correctly default namespace', () => {
+    const emitter = EventEmitterSelective(
+      () => true,
+      () => [],
+      () => 'default'
+    );
+    const handler = jest.fn();
+    const listener = emitter.listenSome(handler);
+
+    // subscribe to default ns
+    listener.subscribeNs();
+
+    // emmit
+    emitter.emit(['default']);
+    // should be ignored
+    emitter.emit(['c']);
+
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  it('unsubscribes', () => {
+    const emitter = EventEmitterSelective(
+      () => true,
+      () => [],
+      () => ''
+    );
+    const handler = jest.fn();
+    const listener = emitter.listen(handler);
+
+    emitter.emit();
+
+    listener.unsubscribe();
+    emitter.emit();
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  it('groups events correctly', async () => {
+    const emitter = EventEmitterSelective(
+      () => true,
+      () => ['test', 'opqrst'],
+      () => ''
+    );
+    const handler = jest.fn();
+    const hanlderAll = jest.fn();
+    const listener = emitter.listenSome(handler);
+    const listenerAll = emitter.listen(hanlderAll);
+
+    listener.subscribeNs('test');
+
+    // is fallback should always call handler
+    emitter.emit(['opqrst'], true);
+
+    await new Promise((resolve) => setTimeout(resolve));
+
+    expect(hanlderAll).toBeCalledTimes(1);
+    expect(handler).toBeCalledTimes(1);
+
+    // these should be merged together
+    emitter.emit(['abcd'], true);
+    emitter.emit(['abcd']);
+
+    expect(hanlderAll).toBeCalledTimes(2);
+    expect(handler).toBeCalledTimes(1);
+
+    listener.unsubscribe();
+    listenerAll.unsubscribe();
+    emitter.emit();
+  });
+
+  it('always subscribes to fallback ns', async () => {
+    const emitter = EventEmitterSelective(
+      () => true,
+      () => ['fallback1', 'fallback2'],
+      () => ''
+    );
+    const handler = jest.fn();
+    emitter.listenSome(handler);
+
+    emitter.emit(['fallback1']);
+    expect(handler).toBeCalledTimes(1);
+
+    emitter.emit(['fallback2']);
+    expect(handler).toBeCalledTimes(2);
+
+    emitter.emit(['test']);
+    expect(handler).toBeCalledTimes(2);
+  });
+
+  it('switches off emitting', () => {
+    const emitter = EventEmitterSelective(
+      () => false,
+      () => ['fallback1', 'fallback2'],
+      () => ''
+    );
+    const handler = jest.fn();
+    emitter.listenSome(handler);
+
+    emitter.emit(['fallback1']);
+    expect(handler).toBeCalledTimes(0);
+
+    emitter.emit(['fallback2']);
+    expect(handler).toBeCalledTimes(0);
+
+    emitter.emit(['']);
+    expect(handler).toBeCalledTimes(0);
+  });
+});