@planningcenter/chat-react-native 4.8.0-qa-staging.12 → 4.8.0-qa-staging.13

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.
@@ -1,4 +1,4 @@
1
- import { ApiCollection, ApiResource, FailedResponse, OAuthToken } from '../../types'
1
+ import { ApiCollection, ApiResource, FailedResponse } from '../../types'
2
2
  import { isResponseLike } from '../response_error'
3
3
  import {
4
4
  concatRecords,
@@ -10,23 +10,18 @@ import {
10
10
  } from './request_helpers'
11
11
  import { DeleteRequest, GetRequest, PatchRequest, PostRequest, WalkRequest } from './types'
12
12
 
13
- type RefreshedToken = Pick<OAuthToken, 'access_token'>
14
- type Headers = Record<string, string>
15
-
16
- export type OnUnauthorizedResponse = (
17
- _response: FailedResponse
18
- ) => void | Promise<RefreshedToken | void>
13
+ export type OnUnauthorizedResponse = (_response: FailedResponse) => void
19
14
 
20
15
  type ClientArgs = {
21
16
  version: string
22
- defaultHeaders?: Headers
17
+ defaultHeaders?: Record<string, string>
23
18
  onUnauthorizedResponse?: OnUnauthorizedResponse
24
19
  root?: string
25
20
  }
26
21
 
27
22
  export class Client {
28
23
  version: string = ''
29
- defaultHeaders: Headers = {}
24
+ defaultHeaders: Record<string, string> = {}
30
25
  onUnauthorizedResponse?: OnUnauthorizedResponse
31
26
  root?: string
32
27
 
@@ -40,129 +35,91 @@ export class Client {
40
35
  async get<T extends ApiCollection | ApiResource>(args: GetRequest): Promise<T> {
41
36
  const { walk, ...data } = args.data
42
37
  const isWalking = Boolean(walk)
38
+ const headers = { ...this.headers, ...args.headers }
43
39
  const url = this.appUrl(args.url)
44
40
 
45
41
  await throwErrorIfQueryParams(url)
46
42
 
47
- return this.send(
48
- headers => {
49
- const requestArgs: MakeRequestArgs = { data, url, action: 'GET', headers }
50
-
51
- const walkRequest = ({
52
- url: requestUrl,
53
- data: d = { fields: {} },
54
- acc = { data: [], included: [], meta: {}, links: {} },
55
- ...options
56
- }: WalkRequest): Promise<T> => {
57
- return makeRequest({
58
- action: 'GET',
59
- data: d,
60
- url: requestUrl,
61
- ...options,
62
- headers,
63
- }).then(({ links, ...rest }) => {
64
- const records = Array.isArray(rest.data) ? concatRecords(acc, rest) : rest
65
-
66
- // `next` will have our params in the link so we do not want to pass them back in
67
- if (links?.next) {
68
- return walkRequest({ ...options, data: d, url: links.next, acc: records })
69
- } else {
70
- return records
71
- }
72
- })
43
+ const requestArgs: MakeRequestArgs = { data, url, action: 'GET', headers }
44
+
45
+ const walkRequest = ({
46
+ url: requestUrl,
47
+ data: d = { fields: {} },
48
+ acc = { data: [], included: [], meta: {}, links: {} },
49
+ ...options
50
+ }: WalkRequest): Promise<T> => {
51
+ return makeRequest({
52
+ action: 'GET',
53
+ data: d,
54
+ url: requestUrl,
55
+ ...options,
56
+ headers,
57
+ }).then(({ links, ...rest }) => {
58
+ const records = Array.isArray(rest.data) ? concatRecords(acc, rest) : rest
59
+
60
+ // `next` will have our params in the link so we do not want to pass them back in
61
+ if (links?.next) {
62
+ return walkRequest({ ...options, data: d, url: links.next, acc: records })
63
+ } else {
64
+ return records
73
65
  }
66
+ })
67
+ }
74
68
 
75
- const handler = isWalking
76
- ? (a: MakeRequestArgs | WalkRequest) => walkRequest(a as WalkRequest)
77
- : (a: MakeRequestArgs | WalkRequest) => makeRequest(a as MakeRequestArgs)
69
+ const handler = isWalking
70
+ ? (a: MakeRequestArgs | WalkRequest) => walkRequest(a as WalkRequest)
71
+ : (a: MakeRequestArgs | WalkRequest) => makeRequest(a as MakeRequestArgs)
78
72
 
79
- return throwErrorIfFieldsMissing(handler, requestArgs).then(response => response as T)
80
- },
81
- { ...this.headers, ...args.headers }
82
- )
73
+ return throwErrorIfFieldsMissing(handler, requestArgs)
74
+ .then(response => response as T)
75
+ .catch(this.handleNotOk)
83
76
  }
84
77
 
85
78
  async patch<T extends ApiCollection | ApiResource>(args: PatchRequest): Promise<T> {
79
+ const headers = { ...this.headers, ...args.headers }
86
80
  const url = this.appUrl(args.url)
87
81
 
88
- return this.send(
89
- headers => {
90
- const requestArgs: MakeRequestArgs = { data: args.data, url, action: 'PATCH', headers }
82
+ const requestArgs: MakeRequestArgs = { data: args.data, url, action: 'PATCH', headers }
91
83
 
92
- return ensureNoQueryParamsInDev(makeRequest, requestArgs).then(response => response as T)
93
- },
94
- { ...this.headers, ...args.headers }
95
- )
84
+ return ensureNoQueryParamsInDev(makeRequest, requestArgs)
85
+ .then(response => response as T)
86
+ .catch(this.handleNotOk)
96
87
  }
97
88
 
98
89
  async post<T extends ApiCollection | ApiResource>(args: PostRequest): Promise<T> {
90
+ const headers = { ...this.headers, ...args.headers }
99
91
  const url = this.appUrl(args.url)
100
92
 
101
- return this.send(
102
- headers => {
103
- const requestArgs: MakeRequestArgs = {
104
- ...args,
105
- data: args.data,
106
- url,
107
- action: 'POST',
108
- headers,
109
- }
93
+ const requestArgs: MakeRequestArgs = { ...args, data: args.data, url, action: 'POST', headers }
110
94
 
111
- return ensureNoQueryParamsInDev(makeRequest, requestArgs).then(response => response as T)
112
- },
113
- { ...this.headers, ...args.headers }
114
- )
95
+ return ensureNoQueryParamsInDev(makeRequest, requestArgs)
96
+ .then(response => response as T)
97
+ .catch(this.handleNotOk)
115
98
  }
116
99
 
117
100
  async delete(args: DeleteRequest) {
101
+ const headers = { ...this.headers, ...args.headers }
118
102
  const url = this.appUrl(args.url)
119
103
 
120
- return this.send(headers => makeRequest({ url, action: 'DELETE', headers }), {
121
- ...this.headers,
122
- ...args.headers,
123
- })
124
- }
104
+ const requestArgs: MakeRequestArgs = { url, action: 'DELETE', headers }
125
105
 
126
- private send<T>(request: (_headers: Headers) => Promise<T>, headers: Headers): Promise<T> {
127
- return request(headers).catch((error: Response | Error) =>
128
- this.handleNotOk(error, ({ access_token }) =>
129
- request({ ...headers, Authorization: `Bearer ${access_token}` }).catch(
130
- (retryError: Response | Error) => this.handleNotOk(retryError)
131
- )
132
- )
133
- )
106
+ return makeRequest(requestArgs).catch(this.handleNotOk)
134
107
  }
135
108
 
136
- handleNotOk = async <T = never>(
137
- response: Response | Error,
138
- retry?: (_token: RefreshedToken) => Promise<T>
139
- ): Promise<T> => {
109
+ handleNotOk = async (response: Response | Error) => {
140
110
  if (!isResponseLike(response)) return Promise.reject(response)
141
111
 
142
112
  const errorData = await this.parseErrorResponse(response)
143
113
  const notOkResponse = response.clone() as FailedResponse
144
114
  notOkResponse.errors = errorData.errors || []
145
115
 
146
- if (response.status !== 401) return Promise.reject(notOkResponse)
147
-
148
- const refreshedToken = await this.refreshedTokenFor(notOkResponse)
149
-
150
- if (refreshedToken && retry) return retry(refreshedToken)
116
+ if (response.status === 401) {
117
+ this.onUnauthorizedResponse?.(notOkResponse)
118
+ }
151
119
 
152
120
  return Promise.reject(notOkResponse)
153
121
  }
154
122
 
155
- private refreshedTokenFor = async (
156
- response: FailedResponse
157
- ): Promise<RefreshedToken | undefined> => {
158
- try {
159
- const token = await this.onUnauthorizedResponse?.(response)
160
- return token && token.access_token ? token : undefined
161
- } catch {
162
- return undefined
163
- }
164
- }
165
-
166
123
  parseErrorResponse = async (response: Response): Promise<Partial<FailedResponse>> => {
167
124
  try {
168
125
  return (await response.clone().json()) as FailedResponse