getta 0.2.3 → 0.4.0

package/src/main.ts

@@ -12,6 +12,7 @@ import {
   DEFAULT_MAX_REDIRECTS,
   DEFAULT_MAX_RETRIES,
   DEFAULT_PATH_TEMPLATE_REGEX,
+  DEFAULT_RATE_LIMIT,
   DEFAULT_REQUEST_RETRY_WAIT,
   DELETE_METHOD,
   ETAG_HEADER,
@@ -31,7 +32,9 @@ import {
   POST_METHOD,
   PUT_METHOD,
   REDIRECTION_REPSONSE,
+  REQUEST_SENT,
   RESOURCE_NOT_FOUND_ERROR,
+  RESPONSE_RECEIVED,
   SERVER_ERROR_REPSONSE,
 } from "./constants";
 import buildEndpoint from "./helpers/build-endpoint";
@@ -44,10 +47,13 @@ import {
   FetchOptions,
   FetchRedirectHandlerOptions,
   FetchResponse,
+  Log,
   PathTemplateCallback,
   PendingRequestResolver,
   PendingRequestResolvers,
+  Performance,
   RequestOptions,
+  RequestQueue,
   RequestTracker,
   ShortcutProperties,
   Shortcuts,
@@ -61,12 +67,18 @@ export class Getta {
   private _conditionalRequestsEnabled: boolean;
   private _fetchTimeout: number;
   private _headers: StringObject;
+  private _log: Log | undefined;
   private _maxRedirects: number;
   private _maxRetries: number;
   private _optionalPathTemplateRegExp: RegExp;
   private _pathTemplateCallback: PathTemplateCallback;
   private _pathTemplateRegExp: RegExp;
+  private _performance: Performance;
   private _queryParams: PlainObject;
+  private _rateLimitCount: number = 0;
+  private _rateLimitedRequestQueue: RequestQueue = [];
+  private _rateLimitPerSecond: number;
+  private _rateLimitTimer: NodeJS.Timer | null = null;
   private _requestRetryWait: number;
   private _requestTracker: RequestTracker = { active: [], pending: new Map() };
   private _streamReader: StreamReader;
@@ -79,12 +91,15 @@ export class Getta {
       enableConditionalRequests = true,
       fetchTimeout = DEFAULT_FETCH_TIMEOUT,
       headers,
+      log,
       maxRedirects = DEFAULT_MAX_REDIRECTS,
       maxRetries = DEFAULT_MAX_RETRIES,
       optionalPathTemplateRegExp = OPTIONAL_PATH_TEMPLATE_REGEX,
       pathTemplateCallback = defaultPathTemplateCallback,
       pathTemplateRegExp = DEFAULT_PATH_TEMPLATE_REGEX,
+      performance,
       queryParams = {},
+      rateLimitPerSecond = DEFAULT_RATE_LIMIT,
       requestRetryWait = DEFAULT_REQUEST_RETRY_WAIT,
       streamReader = JSON_FORMAT,
     } = options;
@@ -99,12 +114,15 @@ export class Getta {
     this._conditionalRequestsEnabled = enableConditionalRequests;
     this._fetchTimeout = fetchTimeout;
     this._headers = { ...DEFAULT_HEADERS, ...(headers || {}) };
+    this._log = log;
     this._maxRedirects = maxRedirects;
     this._maxRetries = maxRetries;
     this._optionalPathTemplateRegExp = optionalPathTemplateRegExp;
     this._pathTemplateCallback = pathTemplateCallback;
     this._pathTemplateRegExp = pathTemplateRegExp;
+    this._performance = performance;
     this._queryParams = queryParams;
+    this._rateLimitPerSecond = rateLimitPerSecond;
     this._requestRetryWait = requestRetryWait;
     this._streamReader = streamReader;
   }
@@ -124,20 +142,26 @@ export class Getta {
       this[requestMethod ?? method](path, merge({}, rest, requestRest)) as Promise<FetchResponse<Resource>>;
   }
 
-  public async delete(path: string, options: Omit<RequestOptions, "method"> = {}) {
-    return this._delete(path, options);
+  public async delete(path: string, options: Omit<RequestOptions, "method"> = {}, context?: PlainObject) {
+    return this._delete(path, options, context);
   }
 
-  public async get(path: string, options: Omit<RequestOptions, "method"> = {}) {
-    return this._get(path, options);
+  public async get(path: string, options: Omit<RequestOptions, "method"> = {}, context?: PlainObject) {
+    return this._get(path, options, context);
   }
 
-  public async post(path: string, options: Omit<Required<RequestOptions, "body">, "method">) {
-    return this._request(path, { ...options, method: POST_METHOD });
+  public async post(path: string, options: Omit<Required<RequestOptions, "body">, "method">, context?: PlainObject) {
+    return this._request(path, { ...options, method: POST_METHOD }, context);
   }
 
-  public async put(path: string, options: Omit<Required<RequestOptions, "body">, "methood">) {
-    return this._request(path, { ...options, method: PUT_METHOD });
+  public async put(path: string, options: Omit<Required<RequestOptions, "body">, "methood">, context?: PlainObject) {
+    return this._request(path, { ...options, method: PUT_METHOD }, context);
+  }
+
+  private _addRequestToRateLimitedQueue(endpoint: string, options: FetchOptions) {
+    return new Promise((resolve: (value: FetchResponse) => void) => {
+      this._rateLimitedRequestQueue.push([resolve, endpoint, options]);
+    });
   }
 
   private async _cacheEntryDelete(requestHash: string): Promise<boolean> {
@@ -183,6 +207,7 @@ export class Getta {
   private async _delete(
     path: string,
     { headers = {}, pathTemplateData, queryParams = {}, ...rest }: Omit<RequestOptions, "method">,
+    context?: PlainObject,
   ) {
     const endpoint = buildEndpoint(this._basePath, path, {
       optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
@@ -199,22 +224,52 @@ export class Getta {
       this._cacheEntryDelete(requestHash);
     }
 
-    return this._fetch(endpoint, {
-      headers: { ...this._headers, ...headers },
-      method: DELETE_METHOD,
-      ...rest,
-    });
+    return this._fetch(
+      endpoint,
+      {
+        headers: { ...this._headers, ...headers },
+        method: DELETE_METHOD,
+        ...rest,
+      },
+      context,
+    );
   }
 
-  private async _fetch(endpoint: string, { redirects, retries, ...rest }: FetchOptions): Promise<FetchResponse> {
+  private async _fetch(
+    endpoint: string,
+    { redirects, retries, ...rest }: FetchOptions,
+    context: PlainObject = {},
+  ): Promise<FetchResponse> {
     try {
       return new Promise(async (resolve: (value: FetchResponse) => void, reject) => {
         const fetchTimer = setTimeout(() => {
           reject(new Error(`${FETCH_TIMEOUT_ERROR} ${this._fetchTimeout}ms.`));
         }, this._fetchTimeout);
 
+        this._rateLimit();
+
+        if (!(this._rateLimitCount < this._rateLimitPerSecond)) {
+          resolve(await this._addRequestToRateLimitedQueue(endpoint, { redirects, retries, ...rest }));
+          return;
+        }
+
+        const startTime = this._performance.now();
+
+        this._log?.(REQUEST_SENT, {
+          context: { redirects, retries, url: endpoint, ...rest, ...context },
+          stats: { startTime },
+        });
+
         const res = await fetch(endpoint, rest);
 
+        const endTime = this._performance.now();
+        const duration = endTime - startTime;
+
+        this._log?.(RESPONSE_RECEIVED, {
+          context: { redirects, retries, url: endpoint, ...rest, ...context },
+          stats: { duration, endTime, startTime },
+        });
+
         clearTimeout(fetchTimer);
 
         const { headers, status } = res;
@@ -228,6 +283,8 @@ export class Getta {
               ...rest,
             }),
           );
+
+          return;
         }
 
         if (responseGroup === SERVER_ERROR_REPSONSE) {
@@ -237,27 +294,17 @@ export class Getta {
               ...rest,
             })) as FetchResponse,
           );
+
+          return;
         }
 
         const fetchRes = res as FetchResponse;
-        const resClone = res.clone();
 
         try {
           fetchRes.data = res.body ? this._bodyParser(await res[this._streamReader]()) : undefined;
           resolve(fetchRes);
         } catch (e) {
-          try {
-            if (this._streamReader === "json" && res.body) {
-              const fetchResClone = resClone as FetchResponse;
-              const text = await resClone.text();
-              fetchResClone.data = JSON.parse(text);
-              resolve(fetchResClone);
-            } else {
-              reject([e, new Error(`Unable to ${rest.method} ${endpoint} due to previous error`)]);
-            }
-          } catch {
-            reject([e, new Error(`Unable to ${rest.method} ${endpoint} due to previous error`)]);
-          }
+          reject([e, new Error(`Unable to ${rest.method} ${endpoint} due to previous error`)]);
         }
       });
     } catch (error) {
@@ -298,6 +345,7 @@ export class Getta {
   private async _get(
     path: string,
     { headers = {}, pathTemplateData, queryParams = {} }: Omit<RequestOptions, "method">,
+    context?: PlainObject,
   ) {
     const endpoint = buildEndpoint(this._basePath, path, {
       optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
@@ -329,7 +377,7 @@ export class Getta {
 
     return this._getResolve(
       requestHash,
-      await this._fetch(endpoint, { headers: { ...this._headers, ...headers }, method: GET_METHOD }),
+      await this._fetch(endpoint, { headers: { ...this._headers, ...headers }, method: GET_METHOD }, context),
     );
   }
 
@@ -367,9 +415,34 @@ export class Getta {
     return res;
   }
 
+  private _rateLimit() {
+    if (!this._rateLimitTimer) {
+      this._rateLimitTimer = setTimeout(() => {
+        this._rateLimitTimer = null;
+        this._rateLimitCount = 0;
+
+        if (this._rateLimitedRequestQueue.length) {
+          this._releaseRateLimitedRequestQueue();
+        }
+      }, 1000);
+    }
+
+    this._rateLimitCount += 1;
+  }
+
+  private _releaseRateLimitedRequestQueue() {
+    this._rateLimitedRequestQueue.forEach(async ([resolve, endpoint, options]) => {
+      // @ts-ignore
+      resolve(await this._fetch(endpoint, options));
+    });
+
+    this._rateLimitedRequestQueue = [];
+  }
+
   private async _request(
     path: string,
     { body, headers, method, pathTemplateData, queryParams, ...rest }: Required<RequestOptions, "method">,
+    context?: PlainObject,
   ) {
     const endpoint = buildEndpoint(this._basePath, path, {
       optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
@@ -379,12 +452,16 @@ export class Getta {
       queryParams: { ...this._queryParams, ...queryParams },
     });
 
-    return this._fetch(endpoint, {
-      body,
-      headers: { ...this._headers, ...headers },
-      method,
-      ...rest,
-    });
+    return this._fetch(
+      endpoint,
+      {
+        body,
+        headers: { ...this._headers, ...headers },
+        method,
+        ...rest,
+      },
+      context,
+    );
   }
 
   private _resolvePendingRequests(requestHash: string, responseData: FetchResponse) {

package/src/types.ts

@@ -17,12 +17,15 @@ export interface ConstructorOptions {
   enableConditionalRequests?: boolean;
   fetchTimeout?: number;
   headers?: StringObject;
+  log?: Log;
   maxRedirects?: number;
   maxRetries?: number;
   optionalPathTemplateRegExp?: RegExp;
   pathTemplateCallback?: PathTemplateCallback;
   pathTemplateRegExp?: RegExp;
+  performance: Performance;
   queryParams?: PlainObject;
+  rateLimitPerSecond?: number;
   requestRetryWait?: number;
   streamReader?: StreamReader;
 }
@@ -41,6 +44,14 @@ export interface FetchRedirectHandlerOptions extends FetchOptions {
   status: number;
 }
 
+export type Log = (message: string, data: PlainObject, logLevel?: LogLevel) => void;
+
+export type LogLevel = "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
+
+export interface Performance {
+  now(): number;
+}
+
 export interface RequestOptions {
   body?: BodyInit;
   headers?: StringObject;
@@ -49,6 +60,8 @@ export interface RequestOptions {
   queryParams?: PlainObject;
 }
 
+export type RequestQueue = [(value: FetchResponse) => void, string, FetchOptions][];
+
 export interface ResponseDataWithErrors<Resource = PlainObject> {
   data?: Resource;
   errors?: Error[];