@scaleway/sdk-client 2.2.1 → 2.2.2

package/dist/scw/fetch/__tests__/http-interceptors.test.js

@@ -0,0 +1,60 @@
+import { ConsoleLogger } from "../../../internal/logger/console-logger.js";
+import { setLogger } from "../../../internal/logger/index.js";
+import { logRequest, logResponse, obfuscateInterceptor } from "../http-interceptors.js";
+import { afterAll, beforeEach, describe, expect, it } from "vitest";
+//#region src/scw/fetch/__tests__/http-interceptors.test.ts
+var latestMessage = "";
+var makeCallbackConsole = (onMessage) => ({
+	...console,
+	debug: onMessage,
+	error: onMessage,
+	info: onMessage,
+	warn: onMessage
+});
+var enableDummyLogger = (logLevel) => {
+	setLogger(new ConsoleLogger(logLevel, "", makeCallbackConsole((obj) => {
+		latestMessage = obj;
+	})));
+};
+beforeEach(() => {
+	latestMessage = "";
+});
+afterAll(() => setLogger(new ConsoleLogger("silent")));
+describe(`logRequest`, () => {
+	const request = new Request("https://api.scaleway.com");
+	it(`logs nothing if the level isn't high enough`, async () => {
+		enableDummyLogger("warn");
+		await logRequest("1")({ request });
+		expect(latestMessage).toBe("");
+	});
+	it(`logs something if the level is high enough`, async () => {
+		enableDummyLogger("debug");
+		await logRequest("1")({ request });
+		expect(latestMessage.startsWith("--------------- Scaleway SDK REQUEST 1")).toBe(true);
+	});
+});
+describe(`logResponse`, () => {
+	const response = new Response("output");
+	it(`logs nothing if the level isn't high enough`, async () => {
+		enableDummyLogger("warn");
+		await logResponse("1")({ response });
+		expect(latestMessage).toBe("");
+	});
+	it(`logs something if the level is high enough`, async () => {
+		enableDummyLogger("debug");
+		await logResponse("1")({ response });
+		expect(latestMessage.startsWith("--------------- Scaleway SDK RESPONSE 1")).toBe(true);
+	});
+});
+describe("obfuscateInterceptor", () => {
+	const prependInterceptor = (preprendValue) => ([name, value]) => [name, `${preprendValue}${value}`];
+	it("changes the request headers", async () => {
+		const obfRequest = await obfuscateInterceptor(prependInterceptor("obj-"))({ request: new Request("https://api.scaleway.com", { headers: { "X-Random-Key": "value" } }) });
+		expect(obfRequest).toBeInstanceOf(Request);
+		expect(obfRequest.headers.get("X-Random-Key")).toBe("obj-value");
+	});
+	it("clones the request without altering the headers", async () => {
+		expect((await obfuscateInterceptor(prependInterceptor("obj-"))({ request: new Request("https://api.scaleway.com", { headers: { "X-Random-Key": "value" } }) })).clone().headers.get("X-Random-Key")).toBe("obj-value");
+	});
+});
+//#endregion

package/dist/scw/fetch/__tests__/resource-paginator.test.js

@@ -0,0 +1,110 @@
+import { enrichForPagination, fetchAll, fetchPaginated } from "../resource-paginator.js";
+import { describe, expect, it, vi } from "vitest";
+//#region src/scw/fetch/__tests__/resource-paginator.test.ts
+var fetchPages = (input = [], delay = 0) => {
+	const totalCount = input.flat().length;
+	const pages = [...input];
+	return () => {
+		const page = {
+			items: pages.shift() ?? [],
+			totalCount
+		};
+		return new Promise((resolve) => {
+			setTimeout(() => resolve(page), delay);
+		});
+	};
+};
+describe("fetchPaginated", () => {
+	it("iterate page by page", async () => {
+		const input = [
+			[{ name: "Alice" }, { name: "Bob" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "David" }]
+		];
+		for await (const page of fetchPaginated("items", fetchPages(input), {})) expect(page).toStrictEqual(input.shift());
+	});
+	it("iterate starting from the desired page", async () => {
+		const input = [
+			[{ name: "Alice" }, { name: "Bob" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "David" }]
+		];
+		let readIndex = 2;
+		for await (const page of fetchPaginated("items", fetchPages(input), { page: readIndex })) {
+			expect(page).toStrictEqual(input[readIndex - 1]);
+			readIndex += 1;
+		}
+	});
+	it("iterate without over iteration - 2 pages", async () => {
+		const twoPages = [[{ name: "Alice" }, { name: "Bob" }], [{ name: "Claire" }]];
+		const twoPagesFetcher = vi.fn(fetchPages(twoPages));
+		for await (const page of fetchPaginated("items", twoPagesFetcher, {})) expect(page).toStrictEqual(twoPages.shift());
+		expect(twoPagesFetcher).toHaveBeenCalledTimes(2);
+	});
+	it("iterate without over iteration - 1 page", async () => {
+		const onePage = [[{ name: "Alice" }, { name: "Bob" }], []];
+		const onePagesFetcher = vi.fn(fetchPages(onePage));
+		for await (const page of fetchPaginated("items", onePagesFetcher, {})) expect(page).toStrictEqual(onePage.shift());
+		expect(onePage).toStrictEqual([[]]);
+		expect(onePagesFetcher).toHaveBeenCalledTimes(1);
+	});
+	it("iterate without over iteration - 1 result", async () => {
+		const singleResult = [[{ name: "Alice" }]];
+		const singleResultFetcher = vi.fn(fetchPages(singleResult));
+		for await (const page of fetchPaginated("items", singleResultFetcher, {})) expect(page).toStrictEqual(singleResult.shift());
+		expect(singleResultFetcher).toHaveBeenCalledTimes(1);
+	});
+	it("returns empty array on empty result", async () => {
+		const iterator = fetchPaginated("items", fetchPages([]), {});
+		const empty = await iterator.next();
+		expect(empty.value).toEqual([]);
+		expect(empty.done).toBe(false);
+		const ended = await iterator.next();
+		expect(ended.value).toEqual(void 0);
+		expect(ended.done).toBe(true);
+	});
+	it("throws when wrong key is provided", async () => {
+		await expect(fetchPaginated("x", fetchPages([]), {}).next()).rejects.toThrow(`Property x is not a list in paginated result`);
+	});
+});
+describe("fetchAll", () => {
+	it("iterate pages in paralel", async () => {
+		const input = [
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }],
+			[{ name: "Julia" }, { name: "Thomas" }]
+		];
+		const delay = 50;
+		const tolerance = 50;
+		const startTime = Date.now();
+		expect(await fetchAll("items", fetchPages(input, 50), {})).toStrictEqual(input.flat());
+		expect(Date.now() - startTime).toBeLessThanOrEqual(2 * delay + tolerance);
+	});
+});
+describe("enrichForPagination", () => {
+	const input = [[{ name: "Rémy" }, { name: "Jaime" }], [{ name: "Vincent" }]];
+	it("can fetch all items", () => expect(enrichForPagination("items", fetchPages(input), {}).all()).resolves.toStrictEqual(input.flat()));
+	it("can fetch items page by page", async () => {
+		let readIndex = 1;
+		for await (const page of enrichForPagination("items", fetchPages(input), { page: readIndex })) {
+			expect(page).toStrictEqual(input[readIndex - 1]);
+			readIndex += 1;
+		}
+	});
+});
+//#endregion

package/dist/scw/fetch/__tests__/response-parser.test.js

@@ -0,0 +1,94 @@
+import { isJSONObject } from "../../../helpers/json.js";
+import { ScalewayError } from "../../errors/scw-error.js";
+import { fixLegacyTotalCount, responseParser } from "../response-parser.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/fetch/__tests__/response-parser.test.ts
+var SIMPLE_REQ_BODY = { "what-is-life": 42 };
+var convertObjToBuffer = (obj) => Buffer.from(JSON.stringify(obj));
+var unmarshalJSON = (obj) => {
+	if (!isJSONObject(obj)) throw new Error(`couldn't unwrap response value`);
+	return obj;
+};
+var makeResponse = (value, status = 200, contentType = void 0) => new Response(value !== null ? new Uint8Array(convertObjToBuffer(value)) : value, {
+	headers: contentType ? { "Content-Type": contentType } : void 0,
+	status
+});
+var makeJSONResponse = (value = SIMPLE_REQ_BODY, status = 200) => makeResponse(value, status, "application/json");
+var makeTextResponse = (value, status = 200) => new Response(value, {
+	headers: { "Content-Type": "plain/text" },
+	status
+});
+describe(`responseParser`, () => {
+	const parseJson = responseParser(unmarshalJSON, "json");
+	const parseAsIs = responseParser((response) => response, "json");
+	const parseBlob = responseParser((response) => response, "blob");
+	it(`triggers a type error for non 'Response' object`, () => expect(parseJson("not-a-response")).rejects.toThrow(/* @__PURE__ */ new TypeError("Invalid response object")));
+	it(`triggers an error for invalid status code`, async () => {
+		return expect(parseJson(new Response(new Uint8Array(convertObjToBuffer(SIMPLE_REQ_BODY)), {
+			headers: { "Content-Type": "application/json" },
+			status: 500
+		}))).rejects.toThrow();
+	});
+	it(`triggers an error with string payload`, async () => {
+		return expect(parseJson(new Response(new Uint8Array(convertObjToBuffer("random-error")), {
+			headers: { "Content-Type": "application/json" },
+			status: 500
+		}))).rejects.toThrow(new ScalewayError(500, "random-error"));
+	});
+	it(`triggers an error with unknown payload`, async () => {
+		return expect(parseJson(new Response(new Uint8Array(convertObjToBuffer(null)), {
+			headers: { "Content-Type": "application/json" },
+			status: 500
+		}))).rejects.toThrow(new ScalewayError(500, "cannot read error response body"));
+	});
+	it(`triggers an error with server response message when parsing fails`, async () => {
+		return expect(parseJson(new Response("text error content", {
+			headers: { "Content-Type": "application/json" },
+			status: 500
+		}))).rejects.toThrow(new ScalewayError(500, "text error content"));
+	});
+	it(`triggers an error for unsuccessful unmarshalling`, async () => {
+		const validResponse = makeJSONResponse();
+		const emptyContentTypeResponse = makeResponse("some-text", 200, "");
+		await expect(responseParser(() => {
+			throw new Error(`couldn't unwrap response value`);
+		}, "json")(validResponse.clone())).rejects.toThrow(new ScalewayError(validResponse.status, `could not parse 'application/json' response: couldn't unwrap response value`));
+		await expect(responseParser(() => {
+			throw "not-of-error-type";
+		}, "text")(validResponse.clone())).rejects.toThrow(new ScalewayError(validResponse.status, `could not parse 'application/json' response`));
+		await expect(responseParser(() => {
+			throw "not-of-error-type";
+		}, "blob")(emptyContentTypeResponse)).rejects.toThrow(new ScalewayError(emptyContentTypeResponse.status, `could not parse '' response`));
+	});
+	it(`returns the response as text for unknown content type`, async () => expect(parseAsIs(makeTextResponse("text-body"))).resolves.toBe("text-body"));
+	it(`returns the proper object for a valid JSON object`, async () => expect(parseJson(makeJSONResponse())).resolves.toMatchObject(SIMPLE_REQ_BODY));
+	it(`returns the proper type for a Blob responseType`, async () => expect(parseBlob(makeTextResponse("hello world")).then((obj) => typeof obj)).resolves.toBe("object"));
+	it(`returns undefined for a 204 status code, even if content-type is json`, async () => expect(parseAsIs(makeJSONResponse(null, 204))).resolves.toBeUndefined());
+});
+describe("fixLegacyTotalCount", () => {
+	it("appends total_count if headers contains the key", () => {
+		expect(fixLegacyTotalCount({ my_key: "anything" }, new Headers({ "x-total-count": "3" }))).toStrictEqual({
+			my_key: "anything",
+			total_count: 3
+		});
+	});
+	it("does nothing if expected key is empty", () => {
+		expect(fixLegacyTotalCount({ my_key: "anything" }, new Headers({}))).toStrictEqual({ my_key: "anything" });
+	});
+	it("does nothing if expected key is not of valid value", () => {
+		expect(fixLegacyTotalCount({ my_key: "anything" }, new Headers({ "x-total-count": "true" }))).toStrictEqual({ my_key: "anything" });
+	});
+	it("does nothing if total_count already exists", () => {
+		expect(fixLegacyTotalCount({
+			my_key: "anything",
+			total_count: 5
+		}, new Headers({ "x-total-count": "3" }))).toStrictEqual({
+			my_key: "anything",
+			total_count: 5
+		});
+	});
+	it("does nothing if input is not a Record", () => {
+		expect(fixLegacyTotalCount("my-value", new Headers({ "x-total-count": "3" }))).toStrictEqual("my-value");
+	});
+});
+//#endregion

package/dist/scw/fetch/build-fetcher.js

@@ -1,8 +1,9 @@
-import { obfuscateAuthHeadersEntry } from "../auth.js";
 import { isBrowser } from "../../helpers/is-browser.js";
+import { obfuscateAuthHeadersEntry } from "../auth.js";
 import { composeRequestInterceptors, composeResponseErrorInterceptors, composeResponseInterceptors } from "../../internal/interceptors/composer.js";
 import { logRequest, logResponse, obfuscateInterceptor } from "./http-interceptors.js";
 import { responseParser } from "./response-parser.js";
+//#region src/scw/fetch/build-fetcher.ts
 /**
 * Builds Request from {@link ScwRequest} & {@link Settings}.
 *
@@ -12,7 +13,7 @@ import { responseParser } from "./response-parser.js";
 *
 * @internal
 */
-const buildRequest = (request, settings) => {
+var buildRequest = (request, settings) => {
 	let { path } = request;
 	if (request.urlParams instanceof URLSearchParams) path = path.concat(`?${request.urlParams.toString()}`);
 	return new Request(`${settings.apiURL}${path}`, {
@@ -35,7 +36,7 @@ var asIs = (response) => response;
 *
 * @internal
 */
-const buildFetcher = (settings, httpClient) => {
+var buildFetcher = (settings, httpClient) => {
 	let requestNumber = 0;
 	const prepareRequest = (requestId) => composeRequestInterceptors([...settings.interceptors.map((obj) => obj.request).filter((obj) => obj), logRequest(requestId, obfuscateInterceptor(obfuscateAuthHeadersEntry))]);
 	const prepareResponse = (requestId) => composeResponseInterceptors([...settings.interceptors.map((obj) => obj.response).filter((obj) => obj), logResponse(requestId)]);
@@ -53,4 +54,5 @@ const buildFetcher = (settings, httpClient) => {
 		}
 	};
 };
-export { buildFetcher };
+//#endregion
+export { buildFetcher, buildRequest };

package/dist/scw/fetch/http-dumper.js

@@ -1,3 +1,4 @@
+//#region src/scw/fetch/http-dumper.ts
 /**
 * Converts a string to PascalCase.
 *
@@ -33,7 +34,7 @@ var serializeHeaders = (headers) => Array.from(headers.entries(), serializeHeade
 *
 * @internal
 */
-const dumpRequest = async (request) => [
+var dumpRequest = async (request) => [
 	`${request.method.toUpperCase()}: ${request.url}`,
 	...serializeHeaders(request.headers),
 	await request.clone().text()
@@ -46,9 +47,10 @@ const dumpRequest = async (request) => [
 *
 * @internal
 */
-const dumpResponse = async (response) => [
+var dumpResponse = async (response) => [
 	`HTTP ${response.status} ${response.ok ? "OK" : "NOK"}`,
 	...serializeHeaders(response.headers),
 	await response.clone().text()
 ].join("\r\n");
+//#endregion
 export { dumpRequest, dumpResponse };

package/dist/scw/fetch/http-interceptors.js

@@ -1,6 +1,7 @@
 import { LevelResolver, shouldLog } from "../../internal/logger/level-resolver.js";
 import { getLogger } from "../../internal/logger/index.js";
 import { dumpRequest, dumpResponse } from "./http-dumper.js";
+//#region src/scw/fetch/http-interceptors.ts
 /**
 * HTTP Request with obfuscated secrets.
 *
@@ -27,7 +28,7 @@ var ObfuscatedRequest = class ObfuscatedRequest extends Request {
 *
 * @internal
 */
-const obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
+var obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
 var identity = ({ request }) => request;
 /**
 * Creates an interceptor to log the requests.
@@ -38,7 +39,7 @@ var identity = ({ request }) => request;
 *
 * @internal
 */
-const logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
+var logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
 	if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) getLogger().debug(`--------------- Scaleway SDK REQUEST ${identifier} ---------------
 ${await dumpRequest(await obfuscate({ request }))}
 ---------------------------------------------------------`);
@@ -52,10 +53,11 @@ ${await dumpRequest(await obfuscate({ request }))}
 *
 * @internal
 */
-const logResponse = (identifier) => async ({ response }) => {
+var logResponse = (identifier) => async ({ response }) => {
 	if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) getLogger().debug(`--------------- Scaleway SDK RESPONSE ${identifier} ---------------
 ${await dumpResponse(response)}
 ---------------------------------------------------------`);
 	return response;
 };
+//#endregion
 export { logRequest, logResponse, obfuscateInterceptor };

package/dist/scw/fetch/resource-paginator.js

@@ -1,4 +1,5 @@
-const extract = (key) => (result) => result[key];
+//#region src/scw/fetch/resource-paginator.ts
+var extract = (key) => (result) => result[key];
 function* pages(key, fetcher, request, firstPage) {
 	if (!Array.isArray(firstPage[key])) throw new Error(`Property ${key} is not a list in paginated result`);
 	const getList = extract(key);
@@ -39,7 +40,7 @@ async function* fetchPaginated(key, fetcher, request, initial = fetcher(request)
 * @param initial - The first page
 * @returns A resources array Promise
 */
-const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
+var fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
 /**
 * Enriches a listing method with helpers.
 *
@@ -50,11 +51,12 @@ const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (a
 *
 * @internal
 */
-const enrichForPagination = (key, fetcher, request) => {
+var enrichForPagination = (key, fetcher, request) => {
 	const firstPage = fetcher(request);
 	return Object.assign(firstPage, {
 		all: () => fetchAll(key, fetcher, request, firstPage),
 		[Symbol.asyncIterator]: () => fetchPaginated(key, fetcher, request, firstPage)
 	});
 };
-export { enrichForPagination };
+//#endregion
+export { enrichForPagination, extract, fetchAll, fetchPaginated };

package/dist/scw/fetch/response-parser.js

@@ -2,6 +2,7 @@ import { isJSONObject } from "../../helpers/json.js";
 import { isResponse } from "../../helpers/is-response.js";
 import { ScalewayError } from "../errors/scw-error.js";
 import { parseScalewayError } from "../errors/error-parser.js";
+//#region src/scw/fetch/response-parser.ts
 var X_TOTAL_COUNT_HEADER_KEY = "x-total-count";
 var TOTAL_COUNT_RES_KEY = "total_count";
 /**
@@ -9,7 +10,7 @@ var TOTAL_COUNT_RES_KEY = "total_count";
 *
 * @internal
 */
-const fixLegacyTotalCount = (obj, headers) => {
+var fixLegacyTotalCount = (obj, headers) => {
 	const headerVal = headers.get(X_TOTAL_COUNT_HEADER_KEY);
 	if (!headerVal) return obj;
 	const totalCount = parseInt(headerVal, 10);
@@ -34,7 +35,7 @@ const fixLegacyTotalCount = (obj, headers) => {
 *
 * @internal
 */
-const responseParser = (unmarshaller, responseType) => async (response) => {
+var responseParser = (unmarshaller, responseType) => async (response) => {
 	if (!isResponse(response)) throw new TypeError("Invalid response object");
 	if (response.ok) {
 		if (response.status === 204) return unmarshaller(void 0);
@@ -51,4 +52,5 @@ const responseParser = (unmarshaller, responseType) => async (response) => {
 	if (isJSONObject(error)) throw parseScalewayError(response.status, error);
 	throw new ScalewayError(response.status, typeof error === "string" ? error : "cannot read error response body");
 };
-export { responseParser };
+//#endregion
+export { fixLegacyTotalCount, responseParser };

package/dist/scw/locality.js

@@ -1,3 +1,4 @@
+//#region src/scw/locality.ts
 function toApiLocality(legacy) {
 	if (!legacy) return { type: "unspecified" };
 	const { zones, regions } = legacy;
@@ -11,4 +12,5 @@ function toApiLocality(legacy) {
 	};
 	return { type: "global" };
 }
+//#endregion
 export { toApiLocality };

package/dist/vendor/base64/index.js

@@ -1,3 +1,4 @@
+//#region src/vendor/base64/index.js
 var lookup = [];
 var revLookup = [];
 var i;
@@ -40,4 +41,5 @@ function fromByteArray(uint8) {
 	}
 	return parts.join("");
 }
+//#endregion
 export { fromByteArray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scaleway/sdk-client",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "license": "Apache-2.0",
   "description": "Scaleway SDK Client",
   "keywords": [