rest-client-sdk 6.6.1 → 7.0.0-rc.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -6,6 +6,7 @@ import AbstractClient from './client/AbstractClient';
6
6
  import { Token } from './TokenGenerator/types';
7
7
  import type RestClientSdkInterface from './RestClientSdkInterface';
8
8
  import type { Config } from './RestClientSdkInterface';
9
+ import { Logger } from './utils/logging';
9
10
  declare type Entity = any;
10
11
  export declare type MetadataDefinition = {
11
12
  entity: Entity;
@@ -19,6 +20,7 @@ declare class RestClientSdk<M extends SdkMetadata> implements RestClientSdkInter
19
20
  serializer: SerializerInterface;
20
21
  mapping: Mapping;
21
22
  unitOfWork: UnitOfWork;
23
+ readonly logger?: Logger;
22
24
  constructor(tokenStorage: TokenStorageInterface<Token>, config: Config, mapping: Mapping, serializer?: SerializerInterface);
23
25
  /**
24
26
  * get a repository by it's metadata "key" attribute
@@ -3,6 +3,7 @@ import { SdkMetadata } from './RestClientSdk';
3
3
  import { Token } from './TokenGenerator/types';
4
4
  import TokenStorageInterface from './TokenStorageInterface';
5
5
  import Mapping from './Mapping';
6
+ import { Logger } from '.';
6
7
  export declare type Config = {
7
8
  path: string;
8
9
  scheme: string;
@@ -11,9 +12,11 @@ export declare type Config = {
11
12
  authorizationType?: string;
12
13
  useDefaultParameters?: boolean;
13
14
  unitOfWorkEnabled?: boolean;
15
+ loggerEnabled?: boolean;
14
16
  };
15
17
  export default interface RestClientSdkInterface<M extends SdkMetadata> {
16
18
  tokenStorage: TokenStorageInterface<Token>;
17
19
  mapping: Mapping;
20
+ readonly logger?: Logger;
18
21
  getRepository<K extends keyof M & string>(key: K): AbstractClient<M[K]>;
19
22
  }
@@ -1,5 +1,6 @@
1
1
  import TokenGeneratorInterface, { TokenBodyReturn } from './TokenGeneratorInterface';
2
2
  import { Token, TokenResponse } from './types';
3
+ import { Logger } from '../utils/logging';
3
4
  interface UrlConfig {
4
5
  scheme: string;
5
6
  path: string;
@@ -7,7 +8,8 @@ interface UrlConfig {
7
8
  }
8
9
  declare abstract class AbstractTokenGenerator<T extends Token, C> implements TokenGeneratorInterface<T> {
9
10
  readonly tokenGeneratorConfig: C;
10
- constructor(tokenGeneratorConfig: C);
11
+ protected logger?: Logger;
12
+ constructor(tokenGeneratorConfig: C, logger?: Logger);
11
13
  abstract generateToken(parameters: unknown): Promise<TokenBodyReturn<T> | TokenResponse<T>>;
12
14
  abstract refreshToken(accessToken: null | T): Promise<TokenBodyReturn<T> | TokenResponse<T>>;
13
15
  abstract checkTokenGeneratorConfig(config: C): void;
@@ -3,10 +3,11 @@ import { Token } from './TokenGenerator/types';
3
3
  import AsyncStorageInterface from './AsyncStorageInterface';
4
4
  import type TokenStorageInterface from './TokenStorageInterface';
5
5
  import type { HasExpiresAt } from './TokenStorageInterface';
6
+ import { Logger } from './utils/logging';
6
7
  declare class TokenStorage<T extends Token> implements TokenStorageInterface<T> {
7
8
  #private;
8
9
  accessTokenKey: string;
9
- constructor(tokenGenerator: TokenGeneratorInterface<T>, asyncStorage: AsyncStorageInterface, accessTokenKey?: string);
10
+ constructor(tokenGenerator: TokenGeneratorInterface<T>, asyncStorage: AsyncStorageInterface, accessTokenKey?: string, logger?: Logger);
10
11
  setAsyncStorage(asyncStorage: AsyncStorageInterface): void;
11
12
  hasAccessToken(): Promise<boolean>;
12
13
  getAccessToken(): Promise<null | string>;
@@ -4,3 +4,4 @@ export declare function removeAuthorization(headers: undefined | HeadersInit): u
4
4
  * Does not apply on "Headers" instance as values are string in there.
5
5
  */
6
6
  export declare function removeUndefinedHeaders(headers: HeadersInit): HeadersInit;
7
+ export declare function convertToRecord(headers: HeadersInit): Record<string, string>;
@@ -13,6 +13,7 @@ import Mapping from './Mapping';
13
13
  import ClassMetadata from './Mapping/ClassMetadata';
14
14
  import Attribute from './Mapping/Attribute';
15
15
  import Relation from './Mapping/Relation';
16
+ import { Logger, Log, LoggerHistory } from './utils/logging';
16
17
  import type { Token, ErrorBody, TokenBody, TokenResponse } from './TokenGenerator/types';
17
18
  import type { SdkMetadata, MetadataDefinition } from './RestClientSdk';
18
19
  import type RestClientSdkInterface from './RestClientSdkInterface';
@@ -22,5 +23,5 @@ import type { HasExpiresAt } from './TokenStorageInterface';
22
23
  import type TokenGeneratorInterface from './TokenGenerator/TokenGeneratorInterface';
23
24
  import type AsyncStorageInterface from './AsyncStorageInterface';
24
25
  export default RestClientSdk;
25
- export { AbstractClient, AbstractTokenGenerator, AuthorizationCodeFlowTokenGenerator, ClientCredentialsGenerator, PasswordGenerator, ProvidedTokenGenerator, Serializer, TokenStorage, UnauthorizedError, BadRequestError, ConflictError, ForbiddenError, OauthError, InvalidGrantError, InvalidScopeError, HttpError, InternalServerError, ResourceNotFoundError, Mapping, ClassMetadata, Attribute, Relation, };
26
- export type { SerializerInterface, Token, ErrorBody, TokenResponse, TokenBody, HasExpiresAt, Config, SdkMetadata, RestClientSdkInterface, TokenStorageInterface, TokenGeneratorInterface, AsyncStorageInterface, MetadataDefinition, };
26
+ export { AbstractClient, AbstractTokenGenerator, AuthorizationCodeFlowTokenGenerator, ClientCredentialsGenerator, PasswordGenerator, ProvidedTokenGenerator, Serializer, TokenStorage, UnauthorizedError, BadRequestError, ConflictError, ForbiddenError, OauthError, InvalidGrantError, InvalidScopeError, HttpError, InternalServerError, ResourceNotFoundError, Mapping, ClassMetadata, Attribute, Relation, Logger, };
27
+ export type { SerializerInterface, Token, ErrorBody, TokenResponse, TokenBody, HasExpiresAt, Config, SdkMetadata, RestClientSdkInterface, TokenStorageInterface, TokenGeneratorInterface, AsyncStorageInterface, MetadataDefinition, LoggerHistory, Log, };
@@ -0,0 +1,31 @@
1
+ declare type SdkRequest = RequestInit & {
2
+ url: string;
3
+ };
4
+ declare type SdkResponse = {
5
+ status: number;
6
+ headers: Record<string, string>;
7
+ };
8
+ export declare type SerializableRequest = {
9
+ url: string;
10
+ method?: string;
11
+ headers?: Record<string, string>;
12
+ body?: string;
13
+ };
14
+ export declare type Log = {
15
+ id: string;
16
+ request?: SerializableRequest;
17
+ response?: SdkResponse;
18
+ logTimes: {
19
+ request?: number;
20
+ response?: number;
21
+ };
22
+ };
23
+ export declare type LoggerHistory = Array<Log>;
24
+ export declare class Logger {
25
+ #private;
26
+ get history(): LoggerHistory;
27
+ constructor();
28
+ logRequest(params: SdkRequest): string;
29
+ logResponse(response: Response, requestId?: undefined | string): string;
30
+ }
31
+ export {};
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rest-client-sdk",
3
- "version": "6.6.1",
3
+ "version": "7.0.0-rc.4",
4
4
  "description": "Rest Client SDK for API",
5
5
  "main": "dist/index.js",
6
6
  "module": "dist/index.es.js",
@@ -10,6 +10,7 @@ import type RestClientSdkInterface from './RestClientSdkInterface';
10
10
  // eslint-disable-next-line import/no-duplicates
11
11
  import type { Config } from './RestClientSdkInterface';
12
12
  import { generateRepository } from './utils/repositoryGenerator';
13
+ import { Logger } from './utils/logging';
13
14
 
14
15
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
15
16
  type Entity = any;
@@ -38,6 +39,8 @@ class RestClientSdk<M extends SdkMetadata>
38
39
 
39
40
  #repositoryList: Partial<Record<keyof M, AbstractClient<M[keyof M]>>>;
40
41
 
42
+ public readonly logger?: Logger;
43
+
41
44
  constructor(
42
45
  tokenStorage: TokenStorageInterface<Token>,
43
46
  config: Config,
@@ -60,6 +63,10 @@ class RestClientSdk<M extends SdkMetadata>
60
63
  this.config.unitOfWorkEnabled
61
64
  );
62
65
 
66
+ if (config.loggerEnabled) {
67
+ this.logger = new Logger();
68
+ }
69
+
63
70
  this.#repositoryList = {};
64
71
  }
65
72
 
@@ -77,7 +84,11 @@ class RestClientSdk<M extends SdkMetadata>
77
84
  }
78
85
 
79
86
  // eslint-disable-next-line new-cap
80
- this.#repositoryList[key] = generateRepository<M[K]>(this, metadata);
87
+ this.#repositoryList[key] = generateRepository<M[K]>(
88
+ this,
89
+ metadata,
90
+ this.config.unitOfWorkEnabled
91
+ );
81
92
  }
82
93
 
83
94
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -3,6 +3,7 @@ import { SdkMetadata } from './RestClientSdk';
3
3
  import { Token } from './TokenGenerator/types';
4
4
  import TokenStorageInterface from './TokenStorageInterface';
5
5
  import Mapping from './Mapping';
6
+ import { Logger } from '.';
6
7
 
7
8
  export type Config = {
8
9
  path: string;
@@ -12,11 +13,14 @@ export type Config = {
12
13
  authorizationType?: string; // default to "Bearer", but can be "Basic" or anything
13
14
  useDefaultParameters?: boolean;
14
15
  unitOfWorkEnabled?: boolean;
16
+ loggerEnabled?: boolean;
15
17
  };
16
18
 
17
19
  export default interface RestClientSdkInterface<M extends SdkMetadata> {
18
20
  tokenStorage: TokenStorageInterface<Token>;
19
21
  mapping: Mapping;
20
22
 
23
+ readonly logger?: Logger;
24
+
21
25
  getRepository<K extends keyof M & string>(key: K): AbstractClient<M[K]>;
22
26
  }
@@ -10,6 +10,7 @@ import TokenGeneratorInterface, {
10
10
  TokenBodyReturn,
11
11
  } from './TokenGeneratorInterface';
12
12
  import { ErrorBody, Token, TokenResponse } from './types';
13
+ import { Logger } from '../utils/logging';
13
14
 
14
15
  interface UrlConfig {
15
16
  scheme: string;
@@ -20,7 +21,12 @@ abstract class AbstractTokenGenerator<T extends Token, C>
20
21
  implements TokenGeneratorInterface<T> {
21
22
  readonly tokenGeneratorConfig: C;
22
23
 
23
- constructor(tokenGeneratorConfig: C) {
24
+ protected logger?: Logger;
25
+
26
+ constructor(tokenGeneratorConfig: C, logger?: Logger) {
27
+ if (logger) {
28
+ this.logger = logger;
29
+ }
24
30
  this.tokenGeneratorConfig = tokenGeneratorConfig;
25
31
  if (typeof this.checkTokenGeneratorConfig === 'function') {
26
32
  this.checkTokenGeneratorConfig(this.tokenGeneratorConfig);
@@ -46,7 +46,7 @@ class AuthorizationCodeFlowTokenGenerator extends AbstractTokenGenerator<
46
46
 
47
47
  const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
48
48
 
49
- return fetch(url, {
49
+ const params = {
50
50
  method: 'POST',
51
51
  headers: {
52
52
  'Content-Type': 'application/x-www-form-urlencoded',
@@ -58,7 +58,13 @@ class AuthorizationCodeFlowTokenGenerator extends AbstractTokenGenerator<
58
58
  redirect_uri: this.tokenGeneratorConfig.redirectUri,
59
59
  code: parameters.code,
60
60
  }),
61
- });
61
+ };
62
+
63
+ if (this.logger) {
64
+ this.logger.logRequest({ url, ...params });
65
+ }
66
+
67
+ return fetch(url, params);
62
68
  }
63
69
 
64
70
  /**
@@ -80,7 +86,7 @@ class AuthorizationCodeFlowTokenGenerator extends AbstractTokenGenerator<
80
86
 
81
87
  const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
82
88
 
83
- return fetch(url, {
89
+ const params = {
84
90
  method: 'POST',
85
91
  headers: {
86
92
  'Content-Type': 'application/x-www-form-urlencoded',
@@ -91,7 +97,13 @@ class AuthorizationCodeFlowTokenGenerator extends AbstractTokenGenerator<
91
97
  client_secret: this.tokenGeneratorConfig.clientSecret,
92
98
  refresh_token: oldAccessToken.refresh_token,
93
99
  }),
94
- });
100
+ };
101
+
102
+ if (this.logger) {
103
+ this.logger.logRequest({ url, ...params });
104
+ }
105
+
106
+ return fetch(url, params);
95
107
  }
96
108
 
97
109
  checkTokenGeneratorConfig(
@@ -55,15 +55,21 @@ class ClientCredentialsGenerator extends AbstractTokenGenerator<
55
55
  body.append('scope', this.tokenGeneratorConfig.scope);
56
56
  }
57
57
 
58
- const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
59
-
60
- return fetch(url, {
58
+ const params = {
61
59
  method: 'POST',
62
60
  headers: {
63
61
  'Content-Type': 'application/x-www-form-urlencoded',
64
62
  },
65
63
  body,
66
- });
64
+ };
65
+
66
+ const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
67
+
68
+ if (this.logger) {
69
+ this.logger.logRequest({ url, ...params });
70
+ }
71
+
72
+ return fetch(url, params);
67
73
  }
68
74
 
69
75
  refreshToken(
@@ -59,13 +59,19 @@ class PasswordGenerator extends AbstractTokenGenerator<PasswordToken, Config> {
59
59
 
60
60
  const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
61
61
 
62
- return fetch(url, {
62
+ const params = {
63
63
  method: 'POST',
64
64
  headers: {
65
65
  'Content-Type': 'application/x-www-form-urlencoded',
66
66
  },
67
67
  body,
68
- });
68
+ };
69
+
70
+ if (this.logger) {
71
+ this.logger.logRequest({ url, ...params });
72
+ }
73
+
74
+ return fetch(url, params);
69
75
  }
70
76
 
71
77
  refreshToken(
@@ -91,13 +97,19 @@ class PasswordGenerator extends AbstractTokenGenerator<PasswordToken, Config> {
91
97
 
92
98
  const url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
93
99
 
94
- return fetch(url, {
100
+ const params = {
95
101
  method: 'POST',
96
102
  headers: {
97
103
  'Content-Type': 'application/x-www-form-urlencoded',
98
104
  },
99
105
  body,
100
- });
106
+ };
107
+
108
+ if (this.logger) {
109
+ this.logger.logRequest({ url, ...params });
110
+ }
111
+
112
+ return fetch(url, params);
101
113
  }
102
114
 
103
115
  checkTokenGeneratorConfig(config: Config): void {
@@ -21,6 +21,7 @@ import {
21
21
  isOauthError,
22
22
  OauthError,
23
23
  } from './ErrorFactory';
24
+ import { Logger } from './utils/logging';
24
25
 
25
26
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
26
27
  function isResponse(response: any): response is Response {
@@ -52,16 +53,24 @@ class TokenStorage<T extends Token> implements TokenStorageInterface<T> {
52
53
 
53
54
  #asyncStorage!: AsyncStorageInterface;
54
55
 
56
+ #logger?: Logger;
57
+
55
58
  constructor(
56
59
  tokenGenerator: TokenGeneratorInterface<T>,
57
60
  asyncStorage: AsyncStorageInterface,
58
- accessTokenKey = 'rest_client_sdk.api.access_token'
61
+ accessTokenKey = 'rest_client_sdk.api.access_token',
62
+ logger?: Logger
59
63
  ) {
64
+ if (logger) {
65
+ this.#logger = logger;
66
+ }
60
67
  this.#tokenGenerator = tokenGenerator;
61
68
  this.#hasATokenBeenGenerated = false;
62
69
  this.setAsyncStorage(asyncStorage);
63
70
  this.accessTokenKey = accessTokenKey;
64
71
 
72
+ this.handleTokenResponse = this.handleTokenResponse.bind(this);
73
+
65
74
  this.generateToken = memoizePromise(this.generateToken);
66
75
  this.refreshToken = memoizePromise(this.refreshToken);
67
76
  }
@@ -178,6 +187,12 @@ class TokenStorage<T extends Token> implements TokenStorageInterface<T> {
178
187
  ): Promise<T> {
179
188
  if (isResponse(responseOrBody)) {
180
189
  const response = responseOrBody;
190
+ const originalResponse = response.clone();
191
+
192
+ if (this.#logger) {
193
+ this.#logger.logResponse(response);
194
+ }
195
+
181
196
  return response
182
197
  .json()
183
198
  .then((body) => {
@@ -186,14 +201,17 @@ class TokenStorage<T extends Token> implements TokenStorageInterface<T> {
186
201
  manageOauthError(body, response);
187
202
  } else if (response.status >= 400) {
188
203
  // throw an error if response status code is an "error" status code
189
- throw getHttpErrorFromResponse(response);
204
+ throw getHttpErrorFromResponse(originalResponse);
190
205
  }
191
206
 
192
207
  return body;
193
208
  })
194
209
  .catch((err) => {
195
210
  if (!(err instanceof OauthError)) {
196
- throw new OauthError(err.type, getHttpErrorFromResponse(response));
211
+ throw new OauthError(
212
+ err.type,
213
+ getHttpErrorFromResponse(originalResponse)
214
+ );
197
215
  }
198
216
 
199
217
  throw err;
@@ -265,17 +265,19 @@ class AbstractClient<D extends MetadataDefinition> {
265
265
  response
266
266
  ) as D['list'];
267
267
 
268
- // eslint-disable-next-line no-restricted-syntax
269
- for (const decodedItem of itemList) {
270
- const identifier = this._getEntityIdentifier(decodedItem);
271
- const normalizedItem = this.serializer.normalizeItem(
272
- decodedItem,
273
- this.metadata
274
- );
275
-
276
- // then we register the re-normalized item
277
- if (this.#isUnitOfWorkEnabled && identifier !== null) {
278
- this.sdk.unitOfWork.registerClean(identifier, normalizedItem);
268
+ if (this.#isUnitOfWorkEnabled) {
269
+ // eslint-disable-next-line no-restricted-syntax
270
+ for (const decodedItem of itemList) {
271
+ const identifier = this._getEntityIdentifier(decodedItem);
272
+ const normalizedItem = this.serializer.normalizeItem(
273
+ decodedItem,
274
+ this.metadata
275
+ );
276
+
277
+ // then we register the re-normalized item
278
+ if (identifier !== null) {
279
+ this.sdk.unitOfWork.registerClean(identifier, normalizedItem);
280
+ }
279
281
  }
280
282
  }
281
283
 
@@ -489,8 +491,17 @@ class AbstractClient<D extends MetadataDefinition> {
489
491
  params.headers = removeUndefinedHeaders(params.headers);
490
492
  }
491
493
 
494
+ let logId: undefined|string;
495
+ if (this.sdk.logger) {
496
+ logId = this.sdk.logger.logRequest({ url: input, ...params });
497
+ }
498
+
492
499
  // eslint-disable-next-line consistent-return
493
500
  return fetch(input, params).then((response) => {
501
+ if (this.sdk.logger) {
502
+ this.sdk.logger.logResponse(response, logId);
503
+ }
504
+
494
505
  if (response.status < 400) {
495
506
  return response;
496
507
  }
@@ -39,3 +39,15 @@ export function removeUndefinedHeaders(headers: HeadersInit): HeadersInit {
39
39
 
40
40
  return Object.fromEntries(filterEntries(Object.entries(headers)));
41
41
  }
42
+
43
+ export function convertToRecord(headers: HeadersInit): Record<string, string> {
44
+ if (headers instanceof Headers) {
45
+ return Object.fromEntries(headers.entries());
46
+ }
47
+
48
+ if (Array.isArray(headers)) {
49
+ return Object.fromEntries(headers);
50
+ }
51
+
52
+ return headers;
53
+ }
package/src/index.ts CHANGED
@@ -24,6 +24,8 @@ import Mapping from './Mapping';
24
24
  import ClassMetadata from './Mapping/ClassMetadata';
25
25
  import Attribute from './Mapping/Attribute';
26
26
  import Relation from './Mapping/Relation';
27
+ import { Logger, Log, LoggerHistory } from './utils/logging';
28
+
27
29
  import type {
28
30
  Token,
29
31
  ErrorBody,
@@ -67,6 +69,7 @@ export {
67
69
  ClassMetadata,
68
70
  Attribute,
69
71
  Relation,
72
+ Logger,
70
73
  };
71
74
  export type {
72
75
  SerializerInterface,
@@ -82,4 +85,6 @@ export type {
82
85
  TokenGeneratorInterface,
83
86
  AsyncStorageInterface,
84
87
  MetadataDefinition,
88
+ LoggerHistory,
89
+ Log,
85
90
  };
@@ -0,0 +1,96 @@
1
+ import { convertToRecord } from '../client/headerUtils';
2
+
3
+ type SdkRequest = RequestInit & { url: string };
4
+
5
+ // type SdkResponse = Partial<Response>;
6
+ type SdkResponse = {
7
+ status: number;
8
+ headers: Record<string, string>;
9
+ };
10
+
11
+ const generateId = () =>
12
+ `rest-client-sdk|${Date.now()}-${
13
+ Math.floor(Math.random() * (9e12 - 1)) + 1e12
14
+ }`;
15
+
16
+ export type SerializableRequest = {
17
+ url: string;
18
+ method?: string;
19
+ headers?: Record<string, string>;
20
+ body?: string;
21
+ };
22
+
23
+ export type Log = {
24
+ id: string;
25
+ request?: SerializableRequest;
26
+ response?: SdkResponse;
27
+ logTimes: {
28
+ request?: number;
29
+ response?: number;
30
+ };
31
+ };
32
+
33
+ export type LoggerHistory = Array<Log>;
34
+
35
+ function serializeRequest(req: SdkRequest): SerializableRequest {
36
+ const request = { ...req }; // Make a clone, useful for doing destructive things
37
+ return {
38
+ method: request.method, // The Request Method, e.g. GET, POST, DELETE
39
+ url: request.url, // The URL
40
+ headers: request.headers ? convertToRecord(request.headers) : undefined,
41
+ body: typeof request.body === 'string' ? request.body : undefined,
42
+ };
43
+ }
44
+
45
+ // eslint-disable-next-line import/prefer-default-export
46
+ export class Logger {
47
+ #history: LoggerHistory;
48
+
49
+ get history(): LoggerHistory {
50
+ return this.#history;
51
+ }
52
+
53
+ constructor() {
54
+ this.#history = [];
55
+ }
56
+
57
+ logRequest(params: SdkRequest): string {
58
+ const log: Log = {
59
+ id: generateId(),
60
+ request: serializeRequest(params),
61
+ logTimes: { request: Date.now() },
62
+ };
63
+
64
+ this.#history.push(log);
65
+
66
+ return log.id;
67
+ }
68
+
69
+ logResponse(response: Response, requestId?: undefined | string): string {
70
+ const id = requestId || generateId();
71
+
72
+ // console.log('clone');
73
+ // const clonedResponse = response.clone(); // THIS IS THE LINE THAT CAUSES THE PROBLEM
74
+ // console.log('after clone', clonedResponse.status);
75
+
76
+ const logContent: SdkResponse = {
77
+ status: response.status, // clonedResponse.status,
78
+ headers: Object.fromEntries(response.headers),
79
+ };
80
+
81
+ const foundLogIndex = this.#history.findIndex((log) => log.id === id);
82
+
83
+ if (foundLogIndex > -1) {
84
+ this.#history[foundLogIndex].response = logContent;
85
+ this.#history[foundLogIndex].logTimes.response = Date.now();
86
+ } else {
87
+ this.#history.push({
88
+ id,
89
+ response: logContent,
90
+ logTimes: { response: Date.now() },
91
+ });
92
+ }
93
+
94
+ return id;
95
+ }
96
+ }