23775261474

Committed 30 Mar 2026 03:53PM UTC coverage: 40.41% (-0.05%) from 40.46%

Build # 23775261474

Build Type

push

github

Committed by

web-flow

Commit Message

fix: Correct search content type 'tags' to match API (box/box-openapi#591) (#1382)

Coverage Stats

4649 of 20247 branches covered (22.96%)

Branch coverage included in aggregate %.

0 of 4 new or added lines in 2 files covered. (0.0%)

45 existing lines in 8 files now uncovered.

17178 of 33767 relevant lines covered (50.87%)

157.42 hits per line

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

55.93

/src/managers/trashedItems.ts

import { serializeItems } from '../schemas/items';
import { deserializeItems } from '../schemas/items';
import { serializeClientError } from '../schemas/clientError';
import { deserializeClientError } from '../schemas/clientError';
import { ResponseFormat } from '../networking/fetchOptions';
import { Items } from '../schemas/items';
import { ClientError } from '../schemas/clientError';
import { BoxSdkError } from '../box/errors';
import { Authentication } from '../networking/auth';
import { NetworkSession } from '../networking/network';
import { FetchOptions } from '../networking/fetchOptions';
import { FetchResponse } from '../networking/fetchResponse';
import { prepareParams } from '../internal/utils';
import { toString } from '../internal/utils';
import { ByteStream } from '../internal/utils';
import { CancellationToken } from '../internal/utils';
import { sdToJson } from '../serialization/json';
import { SerializedData } from '../serialization/json';
import { sdIsEmpty } from '../serialization/json';
import { sdIsBoolean } from '../serialization/json';
import { sdIsNumber } from '../serialization/json';
import { sdIsString } from '../serialization/json';
import { sdIsList } from '../serialization/json';
import { sdIsMap } from '../serialization/json';
export type GetTrashedItemsQueryParamsDirectionField = 'ASC' | 'DESC' | string;
export type GetTrashedItemsQueryParamsSortField =
  | 'name'
  | 'date'
  | 'size'
  | string;
export interface GetTrashedItemsQueryParams {
  /**
   * A comma-separated list of attributes to include in the
   * response. This can be used to request fields that are
   * not normally returned in a standard response.
   *
   * Be aware that specifying this parameter will have the
   * effect that none of the standard fields are returned in
   * the response unless explicitly specified, instead only
   * fields for the mini representation are returned, additional
   * to the fields requested. */
  readonly fields?: readonly string[];
  /**
   * The maximum number of items to return per page. */
  readonly limit?: number;
  /**
   * The offset of the item at which to begin the response.
   *
   * Queries with offset parameter value
   * exceeding 10000 will be rejected
   * with a 400 response. */
  readonly offset?: number;
  /**
   * Specifies whether to use marker-based pagination instead of
   * offset-based pagination. Only one pagination method can
   * be used at a time.
   *
   * By setting this value to true, the API will return a `marker` field
   * that can be passed as a parameter to this endpoint to get the next
   * page of the response. */
  readonly usemarker?: boolean;
  /**
   * Defines the position marker at which to begin returning results. This is
   * used when paginating using marker-based pagination.
   *
   * This requires `usemarker` to be set to `true`. */
  readonly marker?: string;
  /**
   * The direction to sort results in. This can be either in alphabetical ascending
   * (`ASC`) or descending (`DESC`) order. */
  readonly direction?: GetTrashedItemsQueryParamsDirectionField;
  /**
   * Defines the **second** attribute by which items
   * are sorted.
   *
   * Items are always sorted by their `type` first, with
   * folders listed before files, and files listed
   * before web links.
   *
   * This parameter is not supported when using marker-based pagination. */
  readonly sort?: GetTrashedItemsQueryParamsSortField;
}
export class GetTrashedItemsHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetTrashedItemsHeaders, 'extraHeaders'> &
      Partial<Pick<GetTrashedItemsHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetTrashedItemsHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  };
}
export class TrashedItemsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<TrashedItemsManager, 'networkSession' | 'getTrashedItems'> &
      Partial<Pick<TrashedItemsManager, 'networkSession'>>,
  ) {
    if (fields.auth !== undefined) {
      this.auth = fields.auth;
    }
    if (fields.networkSession !== undefined) {
      this.networkSession = fields.networkSession;
    }
  }
  /**
   * Retrieves the files and folders that have been moved
   * to the trash.
   *
   * Any attribute in the full files or folders objects can be passed
   * in with the `fields` parameter to retrieve those specific
   * attributes that are not returned by default.
   *
   * This endpoint defaults to use offset-based pagination, yet also supports
   * marker-based pagination using the `marker` parameter.
   *
   * The number of entries returned may be less than `total_count`. For example, if a user deletes items from a shared folder and is later removed as a collaborator, those deleted items will no longer appear in this endpoint’s results, even though they are still included in `total_count`.
   * @param {GetTrashedItemsQueryParams} queryParams Query parameters of getTrashedItems method
   * @param {GetTrashedItemsHeadersInput} headersInput Headers of getTrashedItems method
   * @param {CancellationToken} cancellationToken Token used for request cancellation.
   * @returns {Promise<Items>}
   */
  async getTrashedItems(
    queryParams: GetTrashedItemsQueryParams = {} satisfies GetTrashedItemsQueryParams,
    headersInput: GetTrashedItemsHeadersInput = new GetTrashedItemsHeaders({}),
    cancellationToken?: CancellationToken,
  ): Promise<Items> {
    const headers: GetTrashedItemsHeaders = new GetTrashedItemsHeaders({
      extraHeaders: headersInput.extraHeaders,
    });
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['fields']: queryParams.fields
        ? queryParams.fields.map(toString).join(',')
        : undefined,
      ['limit']: toString(queryParams.limit) as string,
      ['offset']: toString(queryParams.offset) as string,
      ['usemarker']: toString(queryParams.usemarker) as string,
      ['marker']: toString(queryParams.marker) as string,
      ['direction']: toString(queryParams.direction) as string,
      ['sort']: toString(queryParams.sort) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folders/trash/items',
          ) as string,
          method: 'GET',
          params: queryParamsMap,
          headers: headersMap,
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeItems(response.data!),
      rawData: response.data!,
    };
  }
}
export interface TrashedItemsManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}
export function serializeGetTrashedItemsQueryParamsDirectionField(
  val: GetTrashedItemsQueryParamsDirectionField,
): SerializedData {
  return val;
}
export function deserializeGetTrashedItemsQueryParamsDirectionField(
  val: SerializedData,
): GetTrashedItemsQueryParamsDirectionField {
  if (val == 'ASC') {
    return val;
  }
  if (val == 'DESC') {
    return val;
  }
  if (sdIsString(val)) {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize GetTrashedItemsQueryParamsDirectionField",
  });
}
export function serializeGetTrashedItemsQueryParamsSortField(
  val: GetTrashedItemsQueryParamsSortField,
): SerializedData {
  return val;
}
export function deserializeGetTrashedItemsQueryParamsSortField(
  val: SerializedData,
): GetTrashedItemsQueryParamsSortField {
  if (val == 'name') {
    return val;
  }
  if (val == 'date') {
    return val;
  }
  if (val == 'size') {
    return val;
  }
  if (sdIsString(val)) {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize GetTrashedItemsQueryParamsSortField",
  });
}

1	import { serializeItems } from '../schemas/items';
2	import { deserializeItems } from '../schemas/items';	237✔
3	import { serializeClientError } from '../schemas/clientError';
4	import { deserializeClientError } from '../schemas/clientError';
5	import { ResponseFormat } from '../networking/fetchOptions';
6	import { Items } from '../schemas/items';
7	import { ClientError } from '../schemas/clientError';
8	import { BoxSdkError } from '../box/errors';	237✔
9	import { Authentication } from '../networking/auth';
10	import { NetworkSession } from '../networking/network';	237✔
11	import { FetchOptions } from '../networking/fetchOptions';	237✔
12	import { FetchResponse } from '../networking/fetchResponse';
13	import { prepareParams } from '../internal/utils';	237✔
14	import { toString } from '../internal/utils';	237✔
15	import { ByteStream } from '../internal/utils';
16	import { CancellationToken } from '../internal/utils';
17	import { sdToJson } from '../serialization/json';
18	import { SerializedData } from '../serialization/json';
19	import { sdIsEmpty } from '../serialization/json';
20	import { sdIsBoolean } from '../serialization/json';
21	import { sdIsNumber } from '../serialization/json';
22	import { sdIsString } from '../serialization/json';	237✔
23	import { sdIsList } from '../serialization/json';
24	import { sdIsMap } from '../serialization/json';
25	export type GetTrashedItemsQueryParamsDirectionField = 'ASC' \| 'DESC' \| string;
26	export type GetTrashedItemsQueryParamsSortField =
27	\| 'name'
28	\| 'date'
29	\| 'size'
30	\| string;
31	export interface GetTrashedItemsQueryParams {
32	/**
33	* A comma-separated list of attributes to include in the
34	* response. This can be used to request fields that are
35	* not normally returned in a standard response.
36	*
37	* Be aware that specifying this parameter will have the
38	* effect that none of the standard fields are returned in
39	* the response unless explicitly specified, instead only
40	* fields for the mini representation are returned, additional
41	* to the fields requested. */
42	readonly fields?: readonly string[];
43	/**
44	* The maximum number of items to return per page. */
45	readonly limit?: number;
46	/**
47	* The offset of the item at which to begin the response.
48	*
49	* Queries with offset parameter value
50	* exceeding 10000 will be rejected
51	* with a 400 response. */
52	readonly offset?: number;
53	/**
54	* Specifies whether to use marker-based pagination instead of
55	* offset-based pagination. Only one pagination method can
56	* be used at a time.
57	*
58	* By setting this value to true, the API will return a `marker` field
59	* that can be passed as a parameter to this endpoint to get the next
60	* page of the response. */
61	readonly usemarker?: boolean;
62	/**
63	* Defines the position marker at which to begin returning results. This is
64	* used when paginating using marker-based pagination.
65	*
66	* This requires `usemarker` to be set to `true`. */
67	readonly marker?: string;
68	/**
69	* The direction to sort results in. This can be either in alphabetical ascending
70	* (`ASC`) or descending (`DESC`) order. */
71	readonly direction?: GetTrashedItemsQueryParamsDirectionField;
72	/**
73	* Defines the second attribute by which items
74	* are sorted.
75	*
76	* Items are always sorted by their `type` first, with
77	* folders listed before files, and files listed
78	* before web links.
79	*
80	* This parameter is not supported when using marker-based pagination. */
81	readonly sort?: GetTrashedItemsQueryParamsSortField;
82	}
83	export class GetTrashedItemsHeaders {	237✔
84	/**
85	* Extra headers that will be included in the HTTP request. */
86	readonly extraHeaders?: {	6✔
87	readonly [key: string]: undefined \| string;
88	} = {};
89	constructor(
90	fields: Omit<GetTrashedItemsHeaders, 'extraHeaders'> &
91	Partial<Pick<GetTrashedItemsHeaders, 'extraHeaders'>>,
92	) {
93	if (fields.extraHeaders !== undefined) {	6✔
94	this.extraHeaders = fields.extraHeaders;	3✔
95	}
96	}
97	}
98	export interface GetTrashedItemsHeadersInput {
99	/**
100	* Extra headers that will be included in the HTTP request. */
101	readonly extraHeaders?: {
102	readonly [key: string]: undefined \| string;
103	};
104	}
105	export class TrashedItemsManager {	237✔
106	readonly auth?: Authentication;
107	readonly networkSession: NetworkSession = new NetworkSession({});	510✔
108	constructor(
109	fields: Omit<TrashedItemsManager, 'networkSession' \| 'getTrashedItems'> &
110	Partial<Pick<TrashedItemsManager, 'networkSession'>>,
111	) {
112	if (fields.auth !== undefined) {	510✔
113	this.auth = fields.auth;	510✔
114	}
115	if (fields.networkSession !== undefined) {	510✔
116	this.networkSession = fields.networkSession;	510✔
117	}
118	}
119	/**
120	* Retrieves the files and folders that have been moved
121	* to the trash.
122	*
123	* Any attribute in the full files or folders objects can be passed
124	* in with the `fields` parameter to retrieve those specific
125	* attributes that are not returned by default.
126	*
127	* This endpoint defaults to use offset-based pagination, yet also supports
128	* marker-based pagination using the `marker` parameter.
129	*
130	* The number of entries returned may be less than `total_count`. For example, if a user deletes items from a shared folder and is later removed as a collaborator, those deleted items will no longer appear in this endpoint’s results, even though they are still included in `total_count`.
131	* @param {GetTrashedItemsQueryParams} queryParams Query parameters of getTrashedItems method
132	* @param {GetTrashedItemsHeadersInput} headersInput Headers of getTrashedItems method
133	* @param {CancellationToken} cancellationToken Token used for request cancellation.
134	* @returns {Promise<Items>}
135	*/
136	async getTrashedItems(
137	queryParams: GetTrashedItemsQueryParams = {} satisfies GetTrashedItemsQueryParams,	3✔
138	headersInput: GetTrashedItemsHeadersInput = new GetTrashedItemsHeaders({}),	3✔
139	cancellationToken?: CancellationToken,
140	): Promise<Items> {
141	const headers: GetTrashedItemsHeaders = new GetTrashedItemsHeaders({	3✔
142	extraHeaders: headersInput.extraHeaders,
143	});
144	const queryParamsMap: {
145	readonly [key: string]: string;
146	} = prepareParams({	3✔
147	['fields']: queryParams.fields	3!
148	? queryParams.fields.map(toString).join(',')
149	: undefined,
150	['limit']: toString(queryParams.limit) as string,
151	['offset']: toString(queryParams.offset) as string,
152	['usemarker']: toString(queryParams.usemarker) as string,
153	['marker']: toString(queryParams.marker) as string,
154	['direction']: toString(queryParams.direction) as string,
155	['sort']: toString(queryParams.sort) as string,
156	});
157	const headersMap: {
158	readonly [key: string]: string;
159	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
160	const response: FetchResponse =
161	await this.networkSession.networkClient.fetch(	3✔
162	new FetchOptions({
163	url: ''.concat(
164	this.networkSession.baseUrls.baseUrl,
165	'/2.0/folders/trash/items',
166	) as string,
167	method: 'GET',
168	params: queryParamsMap,
169	headers: headersMap,
170	responseFormat: 'json' as ResponseFormat,
171	auth: this.auth,
172	networkSession: this.networkSession,
173	cancellationToken: cancellationToken,
174	}),
175	);
176	return {	3✔
177	...deserializeItems(response.data!),
178	rawData: response.data!,
179	};
180	}
181	}
182	export interface TrashedItemsManagerInput {
183	readonly auth?: Authentication;
184	readonly networkSession?: NetworkSession;
185	}
186	export function serializeGetTrashedItemsQueryParamsDirectionField(	237✔
187	val: GetTrashedItemsQueryParamsDirectionField,
188	): SerializedData {
UNCOV 189	return val;	×
190	}
191	export function deserializeGetTrashedItemsQueryParamsDirectionField(	237✔
192	val: SerializedData,
193	): GetTrashedItemsQueryParamsDirectionField {
UNCOV 194	if (val == 'ASC') {	×
195	return val;	×
196	}
UNCOV 197	if (val == 'DESC') {	×
198	return val;	×
199	}
UNCOV 200	if (sdIsString(val)) {	×
201	return val;	×
202	}
UNCOV 203	throw new BoxSdkError({	×
204	message: "Can't deserialize GetTrashedItemsQueryParamsDirectionField",
205	});
206	}
207	export function serializeGetTrashedItemsQueryParamsSortField(	237✔
208	val: GetTrashedItemsQueryParamsSortField,
209	): SerializedData {
UNCOV 210	return val;	×
211	}
212	export function deserializeGetTrashedItemsQueryParamsSortField(	237✔
213	val: SerializedData,
214	): GetTrashedItemsQueryParamsSortField {
UNCOV 215	if (val == 'name') {	×
216	return val;	×
217	}
UNCOV 218	if (val == 'date') {	×
219	return val;	×
220	}
UNCOV 221	if (val == 'size') {	×
222	return val;	×
223	}
UNCOV 224	if (sdIsString(val)) {	×
225	return val;	×
226	}
UNCOV 227	throw new BoxSdkError({	×
228	message: "Can't deserialize GetTrashedItemsQueryParamsSortField",
229	});
230	}

box / box-node-sdk / 23775261474

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