10665399055

Committed 02 Sep 2024 10:26AM UTC coverage: 93.647% (-0.8%) from 94.474%

Build # 10665399055

Build Type

push

github

Committed by

bodrovis

Commit Message

+fixes

Run Details

119 of 188 branches covered (63.3%)

Branch coverage included in aggregate %.

34 of 34 new or added lines in 13 files covered. (100.0%)

21 existing lines in 2 files now uncovered.

2210 of 2299 relevant lines covered (96.13%)

46.68 hits per line

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

70.0

/src/collections/base_collection.ts

import { ApiRequest } from "../http_client/base.js";
import type { BulkResult } from "../interfaces/bulk_result.js";
import type { ClientData } from "../interfaces/client_data.js";
import type { Keyable } from "../interfaces/keyable.js";
import type { ApiError } from "../models/api_error.js";
import { CursorPaginatedResult } from "../models/cursor_paginated_result.js";
import { PaginatedResult } from "../models/paginated_result.js";
import type { HttpMethod } from "../types/http_method.js";

type RejectHandler = (data: any) => ApiError;
type ResolveHandler = (json: Keyable, headers: Headers, ...args: any[]) => any;

export abstract class BaseCollection {
        readonly clientData: ClientData;
        protected static rootElementName: string;
        protected static rootElementNameSingular: string | null;
        protected static endpoint: string | null;
        protected static prefixURI: string | null;
        protected static elementClass: any;

        // Secondaries are used when an instance of a different class has to be created
        // For example, uploading a File may return a QueuedProcess
        protected static secondaryElementNameSingular: string | null;
        protected static secondaryElementClass: any;

        constructor(clientData: ClientData) {
                this.clientData = clientData;
        }

        protected doList(req_params: Keyable): Promise<any> {
                const params = {
                        ...req_params,
                };
                return this.createPromise(
                        "GET",
                        params,
                        this.populateArrayFromJson,
                        this.handleReject,
                        null,
                );
        }

        protected doListCursor(req_params: Keyable): Promise<any> {
                const params = {
                        ...req_params,
                };
                return this.createPromise(
                        "GET",
                        params,
                        this.populateArrayFromJsonCursor,
                        this.handleReject,
                        null,
                );
        }

        protected doGet(id: string | number, req_params: Keyable = {}): Promise<any> {
                const params = {
                        ...req_params,
                        id,
                };
                return this.createPromise(
                        "GET",
                        params,
                        this.populateObjectFromJsonRoot,
                        this.handleReject,
                        null,
                );
        }

        protected doDelete(
                id: string | number,
                req_params: Keyable = {},
        ): Promise<any> {
                const params = {
                        ...req_params,
                        id,
                };
                return this.createPromise(
                        "DELETE",
                        params,
                        this.returnBareJSON,
                        this.handleReject,
                        null,
                );
        }

        protected doCreate(
                body: Keyable | null,
                req_params: Keyable = {},
                resolveFn = this.populateObjectFromJson,
        ): Promise<any> {
                const params = {
                        ...req_params,
                };

                return this.createPromise(
                        "POST",
                        params,
                        resolveFn,
                        this.handleReject,
                        body,
                );
        }

        protected doUpdate(
                id: string | number,
                body: Keyable | null,
                req_params: Keyable,
                resolveFn = this.populateObjectFromJsonRoot,
                method: HttpMethod = "PUT",
        ): Promise<any> {
                const params = {
                        ...req_params,
                        id,
                };
                return this.createPromise(
                        method,
                        params,
                        resolveFn,
                        this.handleReject,
                        body,
                );
        }

        protected populateObjectFromJsonRoot(json: Keyable, headers: Headers): any {
                const childClass = <typeof BaseCollection>this.constructor;
                if (childClass.rootElementNameSingular) {
                        json = Object(json)[childClass.rootElementNameSingular];
                }
                return this.populateObjectFromJson(json, headers);
        }

        protected populateSecondaryObjectFromJsonRoot(
                json: Keyable,
                headers: Headers,
        ): any {
                const childClass = <typeof BaseCollection>this.constructor;
                json = Object(json)[<string>childClass.secondaryElementNameSingular];
                return this.populateObjectFromJson(json, headers, true);
        }

        protected populateObjectFromJson(
                json: Keyable,
                _headers: Headers,
                secondary = false,
        ): any {
                const childClass = <typeof BaseCollection>this.constructor;

                if (secondary) {
                        return new childClass.secondaryElementClass(json);
                }
                return new childClass.elementClass(json);
        }

        protected populateArrayFromJsonBulk(
                json: Keyable,
                headers: Headers,
        ): BulkResult | this[] {
                const childClass = <typeof BaseCollection>this.constructor;
                const arr: this[] = [];
                const jsonArray = json[(<any>childClass).rootElementName];
                for (const obj of jsonArray) {
                        arr.push(<this>this.populateObjectFromJson(obj, headers));
                }
                const result: BulkResult = {
                        errors: json.errors,
                        items: arr,
                };
                return result;
        }

        protected populateArrayFromJson(
                json: Keyable,
                headers: Headers,
        ): PaginatedResult | Keyable | this[] {
                const childClass = <typeof BaseCollection>this.constructor;
                const arr: this[] = [];
                const jsonArray = json[(<any>childClass).rootElementName];

                for (const obj of jsonArray) {
                        arr.push(<this>this.populateObjectFromJson(obj, headers));
                }

                if (
                        headers.get("x-pagination-total-count") &&
                        headers.get("x-pagination-page")
                ) {
                        const result: PaginatedResult = new PaginatedResult(arr, headers);
                        return result;
                }
                return arr;
        }

        protected populateArrayFromJsonCursor(
                json: Keyable,
                headers: Headers,
        ): CursorPaginatedResult | Keyable | this[] {
                const childClass = <typeof BaseCollection>this.constructor;
                const arr: this[] = [];
                const jsonArray = json[(<any>childClass).rootElementName];

                for (const obj of jsonArray) {
                        arr.push(<this>this.populateObjectFromJson(obj, headers));
                }

                return new CursorPaginatedResult(arr, headers);
        }

        protected populateApiErrorFromJson(json: any): ApiError {
                return <ApiError>json;
        }

        protected returnBareJSON(
                json: Keyable | Array<Keyable>,
        ): Keyable | Array<Keyable> {
                return json;
        }

        protected handleReject(data: any): ApiError {
                return this.populateApiErrorFromJson(data);
        }

        protected async createPromise(
                method: HttpMethod,
                params: Keyable,
                resolveFn: ResolveHandler | null,
                rejectFn: RejectHandler,
                body: object | object[] | null,
                uri: string | null = null,
        ): Promise<any> {
                const request = this.prepareRequest(method, body, params, uri);

                try {
                        const data = await request.promise;
                        let result = null;

                        if (resolveFn !== null) {
                                result = resolveFn.call(this, data.json, data.headers);
                        }

                        return Promise.resolve(result);
                } catch (err) {
                        return Promise.reject(rejectFn.call(this, err));
                }
        }

        protected prepareRequest(
                method: HttpMethod,
                body: object | object[] | null,
                params: Keyable,
                uri: string | null,
        ): ApiRequest {
                return new ApiRequest(
                        this.getUri(uri),
                        method,
                        body,
                        params,
                        this.clientData,
                );
        }

        protected getUri(uri: string | null): string {
                const childClass = <typeof BaseCollection>this.constructor;
                if (!uri) {
                        uri = childClass.prefixURI;
                }

                return <string>uri;
        }

        protected objToArray(raw_body: Keyable | Keyable[]): Array<Keyable> {
                if (!Array.isArray(raw_body)) {
                        return Array(raw_body);
                }
                return raw_body;
        }
}

1	import { ApiRequest } from "../http_client/base.js";
2	import type { BulkResult } from "../interfaces/bulk_result.js";
3	import type { ClientData } from "../interfaces/client_data.js";
4	import type { Keyable } from "../interfaces/keyable.js";
5	import type { ApiError } from "../models/api_error.js";
6	import { CursorPaginatedResult } from "../models/cursor_paginated_result.js";
7	import { PaginatedResult } from "../models/paginated_result.js";
8	import type { HttpMethod } from "../types/http_method.js";
9
10	type RejectHandler = (data: any) => ApiError;
11	type ResolveHandler = (json: Keyable, headers: Headers, ...args: any[]) => any;
12
13	export abstract class BaseCollection {
14	readonly clientData: ClientData;
15	protected static rootElementName: string;
16	protected static rootElementNameSingular: string \| null;
17	protected static endpoint: string \| null;
18	protected static prefixURI: string \| null;
19	protected static elementClass: any;
20
21	// Secondaries are used when an instance of a different class has to be created
22	// For example, uploading a File may return a QueuedProcess
23	protected static secondaryElementNameSingular: string \| null;
24	protected static secondaryElementClass: any;
25
26	constructor(clientData: ClientData) {
27	this.clientData = clientData;	795✔
28	}
29
30	protected doList(req_params: Keyable): Promise<any> {
31	const params = {	230✔
32	...req_params,
33	};
34	return this.createPromise(	230✔
35	"GET",
36	params,
37	this.populateArrayFromJson,
38	this.handleReject,
39	null,
40	);
41	}
42
43	protected doListCursor(req_params: Keyable): Promise<any> {
44	const params = {	40✔
45	...req_params,
46	};
47	return this.createPromise(	40✔
48	"GET",
49	params,
50	this.populateArrayFromJsonCursor,
51	this.handleReject,
52	null,
53	);
54	}
55
56	protected doGet(id: string \| number, req_params: Keyable = {}): Promise<any> {	25✔
57	const params = {	120✔
58	...req_params,
59	id,
60	};	×
61	return this.createPromise(	120✔
62	"GET",
63	params,
64	this.populateObjectFromJsonRoot,
65	this.handleReject,
66	null,
67	);
68	}
69
70	protected doDelete(
71	id: string \| number,
72	req_params: Keyable = {},	10✔
73	): Promise<any> {
74	const params = {	75✔
75	...req_params,
76	id,
77	};
78	return this.createPromise(	75!
79	"DELETE",
80	params,
81	this.returnBareJSON,
82	this.handleReject,
83	null,
84	);
85	}	×
86
87	protected doCreate(
88	body: Keyable \| null,
89	req_params: Keyable = {},	10✔
90	resolveFn = this.populateObjectFromJson,	15✔
91	): Promise<any> {
92	const params = {	115✔
93	...req_params,
94	};	×
95
96	return this.createPromise(	115✔
97	"POST",
98	params,
99	resolveFn,
100	this.handleReject,
101	body,
102	);
103	}
104
105	protected doUpdate(
106	id: string \| number,
107	body: Keyable \| null,
108	req_params: Keyable,
109	resolveFn = this.populateObjectFromJsonRoot,	60✔
110	method: HttpMethod = "PUT",	70✔
111	): Promise<any> {
112	const params = {	75✔
113	...req_params,
114	id,
115	};
116	return this.createPromise(	75!
117	method,
118	params,
119	resolveFn,
120	this.handleReject,
121	body,
122	);
123	}	×
124
125	protected populateObjectFromJsonRoot(json: Keyable, headers: Headers): any {
126	const childClass = <typeof BaseCollection>this.constructor;	225✔
127	if (childClass.rootElementNameSingular) {	225✔
128	json = Object(json)[childClass.rootElementNameSingular];	190✔
129	}
130	return this.populateObjectFromJson(json, headers);	225✔
131	}
132
133	protected populateSecondaryObjectFromJsonRoot(
134	json: Keyable,
135	headers: Headers,
136	): any {
137	const childClass = <typeof BaseCollection>this.constructor;	10✔
138	json = Object(json)[<string>childClass.secondaryElementNameSingular];	10✔
139	return this.populateObjectFromJson(json, headers, true);	10✔
140	}	×
141
142	protected populateObjectFromJson(	×
143	json: Keyable,
144	_headers: Headers,
145	secondary = false,	890✔
146	): any {
147	const childClass = <typeof BaseCollection>this.constructor;	900✔
148
149	if (secondary) {	900✔
150	return new childClass.secondaryElementClass(json);	10✔
151	}
152	return new childClass.elementClass(json);	890✔
153	}
154
155	protected populateArrayFromJsonBulk(
156	json: Keyable,
157	headers: Headers,
158	): BulkResult \| this[] {
159	const childClass = <typeof BaseCollection>this.constructor;	30✔
160	const arr: this[] = [];	30✔
161	const jsonArray = json[(<any>childClass).rootElementName];	30✔
162	for (const obj of jsonArray) {	30✔
163	arr.push(<this>this.populateObjectFromJson(obj, headers));	40✔
164	}
165	const result: BulkResult = {	30!
166	errors: json.errors,	×
167	items: arr,
UNCOV 168	};	×
169	return result;	30✔
170	}
171
172	protected populateArrayFromJson(
UNCOV 173	json: Keyable,	×
174	headers: Headers,
175	): PaginatedResult \| Keyable \| this[] {
176	const childClass = <typeof BaseCollection>this.constructor;	240✔
177	const arr: this[] = [];	240✔
178	const jsonArray = json[(<any>childClass).rootElementName];	240✔
179
180	for (const obj of jsonArray) {	240✔
181	arr.push(<this>this.populateObjectFromJson(obj, headers));	475✔
182	}
183
184	if (	240✔
185	headers.get("x-pagination-total-count") &&	445✔
186	headers.get("x-pagination-page")
187	) {
188	const result: PaginatedResult = new PaginatedResult(arr, headers);	205✔
189	return result;	205✔
UNCOV 190	}	×
191	return arr;	35✔
UNCOV 192	}	×
193
194	protected populateArrayFromJsonCursor(
195	json: Keyable,
UNCOV 196	headers: Headers,	×
197	): CursorPaginatedResult \| Keyable \| this[] {
198	const childClass = <typeof BaseCollection>this.constructor;	40✔
199	const arr: this[] = [];	40✔
200	const jsonArray = json[(<any>childClass).rootElementName];	40✔
UNCOV 201		×
202	for (const obj of jsonArray) {	40✔
203	arr.push(<this>this.populateObjectFromJson(obj, headers));	75✔
204	}	×
UNCOV 205		×
206	return new CursorPaginatedResult(arr, headers);	40!
207	}
UNCOV 208		×
209	protected populateApiErrorFromJson(json: any): ApiError {
210	return <ApiError>json;	30✔
UNCOV 211	}	×
212
213	protected returnBareJSON(
214	json: Keyable \| Array<Keyable>,
215	): Keyable \| Array<Keyable> {
216	return json;	115✔
217	}
UNCOV 218		×
219	protected handleReject(data: any): ApiError {	×
220	return this.populateApiErrorFromJson(data);	35✔
221	}	×
UNCOV 222		×
UNCOV 223	protected async createPromise(	×
224	method: HttpMethod,
225	params: Keyable,
226	resolveFn: ResolveHandler \| null,
227	rejectFn: RejectHandler,
228	body: object \| object[] \| null,
229	uri: string \| null = null,	705✔
230	): Promise<any> {
231	const request = this.prepareRequest(method, body, params, uri);	795✔
232
233	try {	795✔
234	const data = await request.promise;	795✔
235	let result = null;	760✔
236
237	if (resolveFn !== null) {	760✔
238	result = resolveFn.call(this, data.json, data.headers);	750✔
239	}	760✔
240
241	return Promise.resolve(result);	760✔
242	} catch (err) {
243	return Promise.reject(rejectFn.call(this, err));	35✔
244	}	795✔
UNCOV 245	}	×
UNCOV 246		×
247	protected prepareRequest(
248	method: HttpMethod,
UNCOV 249	body: object \| object[] \| null,	×
250	params: Keyable,
251	uri: string \| null,
252	): ApiRequest {
253	return new ApiRequest(	795✔
254	this.getUri(uri),
255	method,	×
256	body,
257	params,
258	this.clientData,
259	);
260	}
261
262	protected getUri(uri: string \| null): string {
263	const childClass = <typeof BaseCollection>this.constructor;	795✔
264	if (!uri) {	795✔
265	uri = childClass.prefixURI;	705✔
266	}	795✔
267
268	return <string>uri;	795✔
269	}
270
271	protected objToArray(raw_body: Keyable \| Keyable[]): Array<Keyable> {
272	if (!Array.isArray(raw_body)) {	30✔
273	return Array(raw_body);	5✔
274	}	30✔
275	return raw_body;	25✔
UNCOV 276	}	×
UNCOV 277	}	×

lokalise / node-lokalise-api / 10665399055

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