12119253031

Committed 02 Dec 2024 12:22PM UTC coverage: 43.366% (-0.02%) from 43.383%

Build # 12119253031

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Introduce `GeneratedCodeError` as base Error (box/box-codegen#606) (#432)

Co-authored-by: box-sdk-build <box-sdk-build@box.com>

Run Details

3885 of 15146 branches covered (25.65%)

Branch coverage included in aggregate %.

70 of 70 new or added lines in 60 files covered. (100.0%)

8 existing lines in 1 file now uncovered.

13578 of 25123 relevant lines covered (54.05%)

80.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.18

/src/networking/fetch.ts

import nodeFetch, { RequestInit } from 'node-fetch';
import type { Readable } from 'stream';

import { BoxApiError, BoxSdkError } from '../box/errors';
import {
  ByteStream,
  generateByteStreamFromBuffer,
  isBrowser,
  readByteStream,
} from '../internal/utils';
import { sdkVersion } from './version';
import {
  SerializedData,
  jsonToSerializedData,
  sdIsMap,
  sdToJson,
  sdToUrlParams,
} from '../serialization/json';
import { Interceptor } from './interceptors.generated';
import { FetchOptions } from './fetchOptions.generated';
import { FetchResponse } from './fetchResponse.generated';

export const userAgentHeader = `Box JavaScript generated SDK v${sdkVersion} (${
  isBrowser() ? navigator.userAgent : `Node ${process.version}`
})`;
export const xBoxUaHeader = constructBoxUAHeader();

export interface MultipartItem {
  readonly partName: string;
  readonly data?: SerializedData;
  readonly fileStream?: ByteStream;
  readonly fileName?: string;
  readonly contentType?: string;
}

type FetchOptionsExtended = FetchOptions & {
  numRetries?: number;
};

async function createRequestInit(options: FetchOptions): Promise<RequestInit> {
  const {
    method = 'GET',
    headers = {},
    contentType: contentTypeInput = 'application/json',
    data,
    fileStream,
  } = options;

  const { contentHeaders = {}, body } = await (async (): Promise<{
    contentHeaders: { [key: string]: string };
    body: Readable | string;
  }> => {
    const contentHeaders: { [key: string]: string } = {};
    if (options.multipartData) {
      const FormData = isBrowser()
        ? window.FormData
        : eval('require')('form-data');
      const formData = new FormData();
      for (const item of options.multipartData) {
        if (item.fileStream) {
          const buffer = await readByteStream(item.fileStream);
          const blob = isBrowser() ? new Blob([buffer]) : buffer;
          contentHeaders['content-md5'] = await calculateMD5Hash(buffer);
          formData.append(item.partName, blob, {
            filename: item.fileName ?? 'file',
            contentType: item.contentType ?? 'application/octet-stream',
          });
        } else if (item.data) {
          formData.append(item.partName, sdToJson(item.data));
        } else {
          throw new BoxSdkError({
            message: 'Multipart item must have either body or fileStream',
          });
        }
      }
      return {
        contentHeaders: {
          ...(!isBrowser() && {
            'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
          }),
          ...contentHeaders,
        },
        body: formData,
      };
    }

    contentHeaders['Content-Type'] = contentTypeInput;
    switch (contentTypeInput) {
      case 'application/json':
      case 'application/json-patch+json':
        return { contentHeaders, body: sdToJson(data) };

      case 'application/x-www-form-urlencoded':
        return { contentHeaders, body: sdToUrlParams(data) };

      case 'application/octet-stream':
        if (!fileStream) {
          throw new BoxSdkError({
            message:
              'fileStream required for application/octet-stream content type',
          });
        }
        return { contentHeaders, body: fileStream };

      default:
        throw new BoxSdkError({
          message: `Unsupported content type : ${contentTypeInput}`,
        });
    }
  })();

  return {
    method,
    headers: {
      ...contentHeaders,
      ...headers,
      ...(options.auth && {
        Authorization: await options.auth.retrieveAuthorizationHeader(
          options.networkSession,
        ),
      }),
      'User-Agent': userAgentHeader,
      'X-Box-UA': xBoxUaHeader,
      // Additional headers will override the default headers
      ...options.networkSession?.additionalHeaders,
    },
    body,
    signal: options.cancellationToken as RequestInit['signal'],
    agent: options.networkSession?.agent,
    ...(fileStream && isBrowser() && { duplex: 'half' }),
  };
}

const DEFAULT_MAX_ATTEMPTS = 5;
const RETRY_BASE_INTERVAL = 1;
const STATUS_CODE_ACCEPTED = 202,
  STATUS_CODE_UNAUTHORIZED = 401,
  STATUS_CODE_TOO_MANY_REQUESTS = 429;

export async function fetch(
  options: FetchOptionsExtended,
): Promise<FetchResponse> {
  const fetchOptions: typeof options = options.networkSession?.interceptors
    ?.length
    ? options.networkSession?.interceptors.reduce(
        (modifiedOptions: FetchOptions, interceptor: Interceptor) =>
          interceptor.beforeRequest(modifiedOptions),
        options,
      )
    : options;
  const fileStreamBuffer = fetchOptions.fileStream
    ? await readByteStream(fetchOptions.fileStream)
    : void 0;
  const requestInit = await createRequestInit({
    ...fetchOptions,
    fileStream: fileStreamBuffer
      ? generateByteStreamFromBuffer(fileStreamBuffer)
      : void 0,
  });

  const { params = {} } = fetchOptions;
  const response = await nodeFetch(
    ''.concat(
      fetchOptions.url,
      Object.keys(params).length === 0 || fetchOptions.url.endsWith('?')
        ? ''
        : '?',
      new URLSearchParams(params).toString(),
    ),
    { ...requestInit, redirect: 'manual' },
  );

  const contentType = response.headers.get('content-type') ?? '';
  const responseBytesBuffer = await response.arrayBuffer();

  const data = ((): SerializedData => {
    if (contentType.includes('application/json')) {
      const text = new TextDecoder().decode(responseBytesBuffer);
      return jsonToSerializedData(text);
    }
    return void 0;
  })();

  const content = generateByteStreamFromBuffer(responseBytesBuffer);

  let fetchResponse: FetchResponse = {
    status: response.status,
    data,
    content,
    headers: Object.fromEntries(Array.from(response.headers.entries())),
  };
  if (fetchOptions.networkSession?.interceptors?.length) {
    fetchResponse = fetchOptions.networkSession?.interceptors.reduce(
      (modifiedResponse: FetchResponse, interceptor: Interceptor) =>
        interceptor.afterRequest(modifiedResponse),
      fetchResponse,
    );
  }

  if (fetchResponse.status >= 300 && fetchResponse.status < 400) {
    if (!fetchResponse.headers['location']) {
      throw new BoxSdkError({
        message: `Unable to follow redirect for ${fetchOptions.url}`,
      });
    }
    return fetch({
      ...options,
      url: fetchResponse.headers['location'],
    });
  }

  const acceptedWithRetryAfter =
    fetchResponse.status === STATUS_CODE_ACCEPTED &&
    fetchResponse.headers['retry-after'];
  const { numRetries = 0 } = fetchOptions;
  if (
    fetchResponse.status >= 400 ||
    (acceptedWithRetryAfter && numRetries < DEFAULT_MAX_ATTEMPTS)
  ) {
    const reauthenticationNeeded =
      fetchResponse.status == STATUS_CODE_UNAUTHORIZED;
    if (reauthenticationNeeded && fetchOptions.auth) {
      await fetchOptions.auth.refreshToken(fetchOptions.networkSession);

      // retry the request right away
      return fetch({
        ...options,
        numRetries: numRetries + 1,
        fileStream: fileStreamBuffer
          ? generateByteStreamFromBuffer(fileStreamBuffer)
          : void 0,
      });
    }

    const isRetryable =
      fetchOptions.contentType !== 'application/x-www-form-urlencoded' &&
      (fetchResponse.status === STATUS_CODE_TOO_MANY_REQUESTS ||
        acceptedWithRetryAfter ||
        fetchResponse.status >= 500);

    if (isRetryable && numRetries < DEFAULT_MAX_ATTEMPTS) {
      const retryTimeout = fetchResponse.headers['retry-after']
        ? parseFloat(fetchResponse.headers['retry-after']!) * 1000
        : getRetryTimeout(numRetries, RETRY_BASE_INTERVAL * 1000);

      await new Promise((resolve) => setTimeout(resolve, retryTimeout));
      return fetch({ ...options, numRetries: numRetries + 1 });
    }

    const [code, contextInfo, requestId, helpUrl] = sdIsMap(fetchResponse.data)
      ? [
          sdToJson(fetchResponse.data['code']),
          sdIsMap(fetchResponse.data['context_info'])
            ? fetchResponse.data['context_info']
            : undefined,
          sdToJson(fetchResponse.data['request_id']),
          sdToJson(fetchResponse.data['help_url']),
        ]
      : [];

    throw new BoxApiError({
      message: `${fetchResponse.status}`,
      timestamp: `${Date.now()}`,
      requestInfo: {
        method: requestInit.method!,
        url: fetchOptions.url,
        queryParams: params,
        headers: (requestInit.headers as { [key: string]: string }) ?? {},
        body:
          typeof requestInit.body === 'string' ? requestInit.body : undefined,
      },
      responseInfo: {
        statusCode: fetchResponse.status,
        headers: fetchResponse.headers,
        body: fetchResponse.data,
        rawBody: new TextDecoder().decode(responseBytesBuffer),
        code: code,
        contextInfo: contextInfo,
        requestId: requestId,
        helpUrl: helpUrl,
      },
    });
  }

  return fetchResponse;
}

async function calculateMD5Hash(data: string | Buffer): Promise<string> {
  /**
   * Calculate the SHA1 hash of the data
   */
  let createHash: any;
  // Browser environment
  if (isBrowser()) {
    let dataBuffer =
      typeof data === 'string' ? new TextEncoder().encode(data) : data;
    let hashBuffer = await window.crypto.subtle.digest('SHA-1', dataBuffer);
    let hashArray = Array.from(new Uint8Array(hashBuffer));
    let hashHex = hashArray
      .map((b) => b.toString(16).padStart(2, '0'))
      .join('');
    return hashHex;
  }

  // Node environment
  createHash = eval('require')('crypto').createHash;
  return createHash('sha1').update(data).digest('hex');
}

function constructBoxUAHeader() {
  const analyticsIdentifiers = {
    agent: `box-javascript-generated-sdk/${sdkVersion}`,
    env: isBrowser()
      ? navigator.userAgent
      : `Node/${process.version.replace('v', '')}`,
  } as Record<string, string>;

  return Object.keys(analyticsIdentifiers)
    .map((k) => `${k}=${analyticsIdentifiers[k]}`)
    .join('; ');
}

// Retry intervals are between 50% and 150% of the exponentially increasing base amount
const RETRY_RANDOMIZATION_FACTOR = 0.5;

/**
 * Calculate the exponential backoff time with randomized jitter
 * @param {int} numRetries Which retry number this one will be
 * @param {int} baseInterval The base retry interval set in config
 * @returns {int} The number of milliseconds after which to retry
 */
export function getRetryTimeout(numRetries: number, baseInterval: number) {
  var minRandomization = 1 - RETRY_RANDOMIZATION_FACTOR;
  var maxRandomization = 1 + RETRY_RANDOMIZATION_FACTOR;
  var randomization =
    Math.random() * (maxRandomization - minRandomization) + minRandomization;
  var exponential = Math.pow(2, numRetries - 1);
  return Math.ceil(exponential * baseInterval * randomization);
}

1	import nodeFetch, { RequestInit } from 'node-fetch';	140✔
2	import type { Readable } from 'stream';
3
4	import { BoxApiError, BoxSdkError } from '../box/errors';	140✔
5	import {	140✔
6	ByteStream,
7	generateByteStreamFromBuffer,
8	isBrowser,
9	readByteStream,
10	} from '../internal/utils';
11	import { sdkVersion } from './version';	140✔
12	import {	140✔
13	SerializedData,
14	jsonToSerializedData,
15	sdIsMap,
16	sdToJson,
17	sdToUrlParams,
18	} from '../serialization/json';
19	import { Interceptor } from './interceptors.generated';
20	import { FetchOptions } from './fetchOptions.generated';
21	import { FetchResponse } from './fetchResponse.generated';
22
23	export const userAgentHeader = `Box JavaScript generated SDK v${sdkVersion} (${	140✔
24	isBrowser() ? navigator.userAgent : `Node ${process.version}`	140!
25	})`;
26	export const xBoxUaHeader = constructBoxUAHeader();	140✔
27
28	export interface MultipartItem {
29	readonly partName: string;
30	readonly data?: SerializedData;
31	readonly fileStream?: ByteStream;
32	readonly fileName?: string;
33	readonly contentType?: string;
34	}
35
36	type FetchOptionsExtended = FetchOptions & {
37	numRetries?: number;
38	};
39
40	async function createRequestInit(options: FetchOptions): Promise<RequestInit> {
41	const {
42	method = 'GET',	×
43	headers = {},	14✔
44	contentType: contentTypeInput = 'application/json',	×
45	data,
46	fileStream,
47	} = options;	1,555✔
48
49	const { contentHeaders = {}, body } = await (async (): Promise<{	1,555!
50	contentHeaders: { [key: string]: string };
51	body: Readable \| string;
52	}> => {	1,555✔
53	const contentHeaders: { [key: string]: string } = {};	1,555✔
54	if (options.multipartData) {	1,555✔
55	const FormData = isBrowser()	108!
56	? window.FormData
57	: eval('require')('form-data');
58	const formData = new FormData();	108✔
59	for (const item of options.multipartData) {	108✔
60	if (item.fileStream) {	214✔
61	const buffer = await readByteStream(item.fileStream);	108✔
62	const blob = isBrowser() ? new Blob([buffer]) : buffer;	108!
63	contentHeaders['content-md5'] = await calculateMD5Hash(buffer);	108✔
64	formData.append(item.partName, blob, {	108✔
65	filename: item.fileName ?? 'file',	324✔
66	contentType: item.contentType ?? 'application/octet-stream',	324✔
67	});
68	} else if (item.data) {	106!
69	formData.append(item.partName, sdToJson(item.data));	106✔
70	} else {
71	throw new BoxSdkError({	×
72	message: 'Multipart item must have either body or fileStream',
73	});
74	}
75	}
76	return {	108✔
77	contentHeaders: {
78	...(!isBrowser() && {	216✔
79	'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
80	}),
81	...contentHeaders,
82	},
83	body: formData,
84	};
85	}
86
87	contentHeaders['Content-Type'] = contentTypeInput;	1,447✔
88	switch (contentTypeInput) {	1,447!
89	case 'application/json':
90	case 'application/json-patch+json':
91	return { contentHeaders, body: sdToJson(data) };	1,150✔
92
93	case 'application/x-www-form-urlencoded':
94	return { contentHeaders, body: sdToUrlParams(data) };	282✔
95
96	case 'application/octet-stream':
97	if (!fileStream) {	15!
98	throw new BoxSdkError({	×
99	message:
100	'fileStream required for application/octet-stream content type',
101	});
102	}
103	return { contentHeaders, body: fileStream };	15✔
104
105	default:
106	throw new BoxSdkError({	×
107	message: `Unsupported content type : ${contentTypeInput}`,
108	});
109	}
110	})();
111
112	return {	1,555✔
113	method,
114	headers: {
115	...contentHeaders,
116	...headers,
117	...(options.auth && {	2,828✔
118	Authorization: await options.auth.retrieveAuthorizationHeader(
119	options.networkSession,
120	),
121	}),
122	'User-Agent': userAgentHeader,
123	'X-Box-UA': xBoxUaHeader,
124	// Additional headers will override the default headers
125	...options.networkSession?.additionalHeaders,	4,665!
126	},
127	body,
128	signal: options.cancellationToken as RequestInit['signal'],
129	agent: options.networkSession?.agent,	4,665!
130	...(fileStream && isBrowser() && { duplex: 'half' }),	1,570!
131	};
132	}
133
134	const DEFAULT_MAX_ATTEMPTS = 5;	140✔
135	const RETRY_BASE_INTERVAL = 1;	140✔
136	const STATUS_CODE_ACCEPTED = 202,	140✔
137	STATUS_CODE_UNAUTHORIZED = 401,	140✔
138	STATUS_CODE_TOO_MANY_REQUESTS = 429;	140✔
139
140	export async function fetch(	140✔
141	options: FetchOptionsExtended,
142	): Promise<FetchResponse> {
143	const fetchOptions: typeof options = options.networkSession?.interceptors	1,555!
144	?.length
145	? options.networkSession?.interceptors.reduce(	30!
146	(modifiedOptions: FetchOptions, interceptor: Interceptor) =>
147	interceptor.beforeRequest(modifiedOptions),	12✔
148	options,
149	)
150	: options;
151	const fileStreamBuffer = fetchOptions.fileStream	1,555✔
152	? await readByteStream(fetchOptions.fileStream)
153	: void 0;
154	const requestInit = await createRequestInit({	1,555✔
155	...fetchOptions,
156	fileStream: fileStreamBuffer	1,555✔
157	? generateByteStreamFromBuffer(fileStreamBuffer)
158	: void 0,
159	});
160
161	const { params = {} } = fetchOptions;	1,555✔
162	const response = await nodeFetch(	1,555✔
163	''.concat(
164	fetchOptions.url,
165	Object.keys(params).length === 0 \|\| fetchOptions.url.endsWith('?')	3,224✔
166	? ''
167	: '?',
168	new URLSearchParams(params).toString(),
169	),
170	{ ...requestInit, redirect: 'manual' },
171	);
172
173	const contentType = response.headers.get('content-type') ?? '';	1,551✔
174	const responseBytesBuffer = await response.arrayBuffer();	1,551✔
175
176	const data = ((): SerializedData => {	1,551✔
177	if (contentType.includes('application/json')) {	1,551✔
178	const text = new TextDecoder().decode(responseBytesBuffer);	1,185✔
179	return jsonToSerializedData(text);	1,185✔
180	}
181	return void 0;	366✔
182	})();
183
184	const content = generateByteStreamFromBuffer(responseBytesBuffer);	1,551✔
185
186	let fetchResponse: FetchResponse = {	1,551✔
187	status: response.status,
188	data,
189	content,
190	headers: Object.fromEntries(Array.from(response.headers.entries())),
191	};
192	if (fetchOptions.networkSession?.interceptors?.length) {	1,551!
193	fetchResponse = fetchOptions.networkSession?.interceptors.reduce(	8!
194	(modifiedResponse: FetchResponse, interceptor: Interceptor) =>
195	interceptor.afterRequest(modifiedResponse),	10✔
196	fetchResponse,
197	);
198	}
199
200	if (fetchResponse.status >= 300 && fetchResponse.status < 400) {	1,551✔
201	if (!fetchResponse.headers['location']) {	14✔
202	throw new BoxSdkError({	2✔
203	message: `Unable to follow redirect for ${fetchOptions.url}`,
204	});
205	}
206	return fetch({	12✔
207	...options,
208	url: fetchResponse.headers['location'],
209	});
210	}
211
212	const acceptedWithRetryAfter =
213	fetchResponse.status === STATUS_CODE_ACCEPTED &&	1,537✔
214	fetchResponse.headers['retry-after'];
215	const { numRetries = 0 } = fetchOptions;	1,537✔
216	if (	1,537✔
217	fetchResponse.status >= 400 \|\|	2,980!
218	(acceptedWithRetryAfter && numRetries < DEFAULT_MAX_ATTEMPTS)
219	) {
220	const reauthenticationNeeded =
221	fetchResponse.status == STATUS_CODE_UNAUTHORIZED;	94✔
222	if (reauthenticationNeeded && fetchOptions.auth) {	94✔
223	await fetchOptions.auth.refreshToken(fetchOptions.networkSession);	2✔
224
225	// retry the request right away
226	return fetch({	×
227	...options,
228	numRetries: numRetries + 1,
229	fileStream: fileStreamBuffer	×
230	? generateByteStreamFromBuffer(fileStreamBuffer)
231	: void 0,
232	});
233	}
234
235	const isRetryable =
236	fetchOptions.contentType !== 'application/x-www-form-urlencoded' &&	92✔
237	(fetchResponse.status === STATUS_CODE_TOO_MANY_REQUESTS \|\|
238	acceptedWithRetryAfter \|\|
239	fetchResponse.status >= 500);
240
241	if (isRetryable && numRetries < DEFAULT_MAX_ATTEMPTS) {	92!
UNCOV 242	const retryTimeout = fetchResponse.headers['retry-after']	×
243	? parseFloat(fetchResponse.headers['retry-after']!) * 1000
244	: getRetryTimeout(numRetries, RETRY_BASE_INTERVAL * 1000);
245
UNCOV 246	await new Promise((resolve) => setTimeout(resolve, retryTimeout));	×
UNCOV 247	return fetch({ ...options, numRetries: numRetries + 1 });	×
248	}
249
250	const [code, contextInfo, requestId, helpUrl] = sdIsMap(fetchResponse.data)	92✔
251	? [
252	sdToJson(fetchResponse.data['code']),
253	sdIsMap(fetchResponse.data['context_info'])	76✔
254	? fetchResponse.data['context_info']
255	: undefined,
256	sdToJson(fetchResponse.data['request_id']),
257	sdToJson(fetchResponse.data['help_url']),
258	]
259	: [];
260
261	throw new BoxApiError({	92✔
262	message: `${fetchResponse.status}`,
263	timestamp: `${Date.now()}`,
264	requestInfo: {
265	method: requestInit.method!,
266	url: fetchOptions.url,
267	queryParams: params,
268	headers: (requestInit.headers as { [key: string]: string }) ?? {},	276!
269	body:
270	typeof requestInit.body === 'string' ? requestInit.body : undefined,	92✔
271	},
272	responseInfo: {
273	statusCode: fetchResponse.status,
274	headers: fetchResponse.headers,
275	body: fetchResponse.data,
276	rawBody: new TextDecoder().decode(responseBytesBuffer),
277	code: code,
278	contextInfo: contextInfo,
279	requestId: requestId,
280	helpUrl: helpUrl,
281	},
282	});
283	}
284
285	return fetchResponse;	1,443✔
286	}
287
288	async function calculateMD5Hash(data: string \| Buffer): Promise<string> {
289	/**
290	* Calculate the SHA1 hash of the data
291	*/
292	let createHash: any;
293	// Browser environment
294	if (isBrowser()) {	108!
295	let dataBuffer =
296	typeof data === 'string' ? new TextEncoder().encode(data) : data;	×
297	let hashBuffer = await window.crypto.subtle.digest('SHA-1', dataBuffer);	×
298	let hashArray = Array.from(new Uint8Array(hashBuffer));	×
299	let hashHex = hashArray	×
300	.map((b) => b.toString(16).padStart(2, '0'))	×
301	.join('');
302	return hashHex;	×
303	}
304
305	// Node environment
306	createHash = eval('require')('crypto').createHash;	108✔
307	return createHash('sha1').update(data).digest('hex');	108✔
308	}
309
310	function constructBoxUAHeader() {
311	const analyticsIdentifiers = {	140✔
312	agent: `box-javascript-generated-sdk/${sdkVersion}`,
313	env: isBrowser()	140!
314	? navigator.userAgent
315	: `Node/${process.version.replace('v', '')}`,
316	} as Record<string, string>;
317
318	return Object.keys(analyticsIdentifiers)	140✔
319	.map((k) => `${k}=${analyticsIdentifiers[k]}`)	280✔
320	.join('; ');
321	}
322
323	// Retry intervals are between 50% and 150% of the exponentially increasing base amount
324	const RETRY_RANDOMIZATION_FACTOR = 0.5;	140✔
325
326	/**
327	* Calculate the exponential backoff time with randomized jitter
328	* @param {int} numRetries Which retry number this one will be
329	* @param {int} baseInterval The base retry interval set in config
330	* @returns {int} The number of milliseconds after which to retry
331	*/
332	export function getRetryTimeout(numRetries: number, baseInterval: number) {	140✔
UNCOV 333	var minRandomization = 1 - RETRY_RANDOMIZATION_FACTOR;	×
UNCOV 334	var maxRandomization = 1 + RETRY_RANDOMIZATION_FACTOR;	×
335	var randomization =
UNCOV 336	Math.random() * (maxRandomization - minRandomization) + minRandomization;	×
UNCOV 337	var exponential = Math.pow(2, numRetries - 1);	×
UNCOV 338	return Math.ceil(exponential * baseInterval * randomization);	×
339	}

box / box-typescript-sdk-gen / 12119253031

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous