Transfrom workspace components to ts (#775)

2 files changed, 82 insertions, 73 deletions

diff --git a/src/stores/lib/CachedRequest.js b/src/stores/lib/CachedRequest.ts
index a6dd47f7d..25cc365e2 100644
--- a/src/stores/lib/CachedRequest.js
+++ b/src/stores/lib/CachedRequest.ts
@@ -3,29 +3,33 @@ import { isEqual, remove } from 'lodash';
 import Request from './Request';
 
 export default class CachedRequest extends Request {
-  _apiCalls = [];
+  _apiCalls: any[] = [];
 
   _isInvalidated = true;
 
-  execute(...callArgs) {
+  execute(...callArgs): this {
     // Do not continue if this request is already loading
-    if (this._isWaitingForResponse) return this;
+    if (this.isWaitingForResponse) {
+      return this;
+    }
 
     // Very simple caching strategy -> only continue if the call / args changed
     // or the request was invalidated manually from outside
     const existingApiCall = this._findApiCall(callArgs);
 
     // Invalidate if new or different api call will be done
-    if (existingApiCall && existingApiCall !== this._currentApiCall) {
+    if (existingApiCall && existingApiCall !== this.currentApiCall) {
       this._isInvalidated = true;
-      this._currentApiCall = existingApiCall;
+      this.currentApiCall = existingApiCall;
     } else if (!existingApiCall) {
       this._isInvalidated = true;
-      this._currentApiCall = this._addApiCall(callArgs);
+      this.currentApiCall = this._addApiCall(callArgs);
     }
 
     // Do not continue if this request is not invalidated (see above)
-    if (!this._isInvalidated) return this;
+    if (!this._isInvalidated) {
+      return this;
+    }
 
     // This timeout is necessary to avoid warnings from mobx
     // regarding triggering actions as side-effect of getters
@@ -41,18 +45,18 @@ export default class CachedRequest extends Request {
     );
 
     // Issue api call & save it as promise that is handled to update the results of the operation
-    this._promise = new Promise(resolve => {
-      this._api[this._method](...callArgs)
+    this.promise = new Promise(resolve => {
+      this.api[this.method](...callArgs)
         .then(result => {
           setTimeout(
             action(() => {
               this.result = result;
-              if (this._currentApiCall) this._currentApiCall.result = result;
+              if (this.currentApiCall) this.currentApiCall.result = result;
               this.isExecuting = false;
               this.isError = false;
               this.wasExecuted = true;
               this._isInvalidated = false;
-              this._isWaitingForResponse = false;
+              this.isWaitingForResponse = false;
               this._triggerHooks();
               resolve(result);
             }),
@@ -68,7 +72,7 @@ export default class CachedRequest extends Request {
                 this.isExecuting = false;
                 this.isError = true;
                 this.wasExecuted = true;
-                this._isWaitingForResponse = false;
+                this.isWaitingForResponse = false;
                 this._triggerHooks();
                 // reject(error);
               }),
@@ -78,26 +82,27 @@ export default class CachedRequest extends Request {
         );
     });
 
-    this._isWaitingForResponse = true;
+    this.isWaitingForResponse = true;
     return this;
   }
 
-  // eslint-disable-next-line unicorn/no-object-as-default-parameter
-  invalidate(options = { immediately: false }) {
+  static defaultOptions = { immediately: false };
+
+  invalidate(options = CachedRequest.defaultOptions): this {
     this._isInvalidated = true;
-    if (options.immediately && this._currentApiCall) {
-      return this.execute(...this._currentApiCall.args);
+    if (options.immediately && this.currentApiCall) {
+      return this.execute(...this.currentApiCall.args);
     }
     return this;
   }
 
-  patch(modify) {
+  patch(modify): Promise<this> {
     return new Promise(resolve => {
       setTimeout(
         action(() => {
           const override = modify(this.result);
           if (override !== undefined) this.result = override;
-          if (this._currentApiCall) this._currentApiCall.result = this.result;
+          if (this.currentApiCall) this.currentApiCall.result = this.result;
           resolve(this);
         }),
         0,
@@ -105,17 +110,17 @@ export default class CachedRequest extends Request {
     });
   }
 
-  removeCacheForCallWith(...args) {
+  removeCacheForCallWith(...args: any): void {
     remove(this._apiCalls, c => isEqual(c.args, args));
   }
 
-  _addApiCall(args) {
+  _addApiCall(args: any) {
     const newCall = { args, result: null };
     this._apiCalls.push(newCall);
     return newCall;
   }
 
-  _findApiCall(args) {
+  _findApiCall(args: any) {
     return this._apiCalls.find(c => isEqual(c.args, args));
   }
 }
diff --git a/src/stores/lib/Request.js b/src/stores/lib/Request.ts
index 60c943a42..f9424ac99 100644
--- a/src/stores/lib/Request.js
+++ b/src/stores/lib/Request.ts
@@ -1,16 +1,18 @@
 import { observable, action, computed, makeObservable } from 'mobx';
 import { isEqual } from 'lodash/fp';
 
+type Hook = (request: Request) => void;
+
 export default class Request {
-  static _hooks = [];
+  static _hooks: Hook[] = [];
 
-  static registerHook(hook) {
+  static registerHook(hook: Hook) {
     Request._hooks.push(hook);
   }
 
-  @observable result = null;
+  @observable result: any = null;
 
-  @observable error = null;
+  @observable error: any = null;
 
   @observable isExecuting = false;
 
@@ -18,43 +20,47 @@ export default class Request {
 
   @observable wasExecuted = false;
 
-  @action _reset() {
-    this.error = null;
-    this.result = null;
-    this.isExecuting = false;
-    this.isError = false;
-    this.wasExecuted = false;
-    this._isWaitingForResponse = false;
-    this._promise = Promise;
+  promise: any = Promise;
 
-    return this;
-  }
+  protected api: any = {};
 
-  _promise = Promise;
+  method = '';
 
-  _api = {};
+  protected isWaitingForResponse = false;
 
-  _method = '';
+  protected currentApiCall: any = null;
 
-  _isWaitingForResponse = false;
+  retry = () => this.reload();
 
-  _currentApiCall = null;
+  reset = () => this._reset();
 
   constructor(api, method) {
     makeObservable(this);
 
-    this._api = api;
-    this._method = method;
+    this.api = api;
+    this.method = method;
+  }
+
+  @action _reset(): this {
+    this.error = null;
+    this.result = null;
+    this.isExecuting = false;
+    this.isError = false;
+    this.wasExecuted = false;
+    this.isWaitingForResponse = false;
+    this.promise = Promise;
+
+    return this;
   }
 
-  execute(...callArgs) {
+  execute(...callArgs: any[]): this {
     // Do not continue if this request is already loading
-    if (this._isWaitingForResponse) return this;
+    if (this.isWaitingForResponse) return this;
 
-    if (!this._api[this._method]) {
+    if (!this.api[this.method]) {
       throw new Error(
-        `Missing method <${this._method}> on api object:`,
-        this._api,
+        `Missing method <${this.method}> on api object:`,
+        this.api,
       );
     }
 
@@ -68,18 +74,18 @@ export default class Request {
     );
 
     // Issue api call & save it as promise that is handled to update the results of the operation
-    this._promise = new Promise((resolve, reject) => {
-      this._api[this._method](...callArgs)
+    this.promise = new Promise((resolve, reject) => {
+      this.api[this.method](...callArgs)
         .then(result => {
           setTimeout(
             action(() => {
               this.error = null;
               this.result = result;
-              if (this._currentApiCall) this._currentApiCall.result = result;
+              if (this.currentApiCall) this.currentApiCall.result = result;
               this.isExecuting = false;
               this.isError = false;
               this.wasExecuted = true;
-              this._isWaitingForResponse = false;
+              this.isWaitingForResponse = false;
               this._triggerHooks();
               resolve(result);
             }),
@@ -95,7 +101,7 @@ export default class Request {
                 this.isExecuting = false;
                 this.isError = true;
                 this.wasExecuted = true;
-                this._isWaitingForResponse = false;
+                this.isWaitingForResponse = false;
                 this._triggerHooks();
                 reject(error);
               }),
@@ -105,51 +111,49 @@ export default class Request {
         );
     });
 
-    this._isWaitingForResponse = true;
-    this._currentApiCall = { args: callArgs, result: null };
+    this.isWaitingForResponse = true;
+    this.currentApiCall = { args: callArgs, result: null };
     return this;
   }
 
-  reload() {
-    const args = this._currentApiCall ? this._currentApiCall.args : [];
+  reload(): this {
+    const args = this.currentApiCall ? this.currentApiCall.args : [];
     this.error = null;
     return this.execute(...args);
   }
 
-  retry = () => this.reload();
-
-  isExecutingWithArgs(...args) {
+  isExecutingWithArgs(...args: any[]): boolean {
     return (
       this.isExecuting &&
-      this._currentApiCall &&
-      isEqual(this._currentApiCall.args, args)
+      this.currentApiCall &&
+      isEqual(this.currentApiCall.args, args)
     );
   }
 
-  @computed get isExecutingFirstTime() {
+  @computed get isExecutingFirstTime(): boolean {
     return !this.wasExecuted && this.isExecuting;
   }
 
   /* eslint-disable unicorn/no-thenable */
-  then(...args) {
-    if (!this._promise)
+  then(...args: any[]) {
+    if (!this.promise)
       throw new Error(
         'You have to call Request::execute before you can access it as promise',
       );
-    return this._promise.then(...args);
+    return this.promise.then(...args);
   }
 
-  catch(...args) {
-    if (!this._promise)
+  catch(...args: any[]) {
+    if (!this.promise)
       throw new Error(
         'You have to call Request::execute before you can access it as promise',
       );
-    return this._promise.catch(...args);
+    return this.promise.catch(...args);
   }
 
-  _triggerHooks() {
-    for (const hook of Request._hooks) hook(this);
+  _triggerHooks(): void {
+    for (const hook of Request._hooks) {
+      hook(this);
+    }
   }
-
-  reset = () => this._reset();
 }