@scaleway/sdk-client 2.2.1 → 2.3.0

package/dist/scw/__tests__/auth.test.js

@@ -0,0 +1,57 @@
+import { authenticateWithSecrets, authenticateWithSessionToken, obfuscateAuthHeadersEntry, obfuscateToken, obfuscateUUID } from "../auth.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/auth.test.ts
+describe("obfuscateToken", () => {
+	it("hides anything after 5 characters", () => {
+		expect(obfuscateToken("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c")).toBe("eyJhbxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+		expect(obfuscateToken("")).toBe("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+	});
+});
+describe("obfuscateUUID", () => {
+	it("hides anything after 8 characters", () => {
+		expect(obfuscateUUID("db31db7b-473d-488e-bd2e-1b77ee426910")).toBe("db31db7b-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+		expect(obfuscateUUID("")).toBe("-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+	});
+});
+describe("obfuscateAuthHeadersEntry", () => {
+	it("obfuscates an auth token", () => {
+		expect(obfuscateAuthHeadersEntry(["x-auth-token", "db31db7b-473d-488e-bd2e-1b77ee426910"])).toStrictEqual(["x-auth-token", "db31db7b-xxxx-xxxx-xxxx-xxxxxxxxxxxx"]);
+	});
+	it("obfuscates a session token", () => {
+		expect(obfuscateAuthHeadersEntry(["x-session-token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"])).toStrictEqual(["x-session-token", "eyJhbxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"]);
+	});
+	it(`doesn't obfuscate unknown key`, () => {
+		expect(obfuscateAuthHeadersEntry(["x-unknown-key", "random-value"])).toStrictEqual(["x-unknown-key", "random-value"]);
+	});
+});
+describe("authenticateWithSessionToken", () => {
+	it("retrieves the token and updates the request header", async () => {
+		const dummyToken = "dummy";
+		const sourceReq = new Request("https://api.scaleway.com/my/path");
+		const updatedReq = await authenticateWithSessionToken(() => Promise.resolve(dummyToken))({ request: sourceReq });
+		const expectedReq = sourceReq.clone();
+		expectedReq.headers.append("x-session-token", "dummy");
+		expect(updatedReq).toMatchObject(expectedReq);
+	});
+});
+describe("authenticateWithSecrets", () => {
+	const sourceReq = new Request("https://api.scaleway.com/my/path");
+	it("updates the request header with the valid secrets", async () => {
+		const validSecrets = {
+			accessKey: "SCW01234567890123456",
+			secretKey: "e4b83996-4c60-449a-98d2-38f5de7b4e6b"
+		};
+		const updatedReq = await authenticateWithSecrets(validSecrets)({ request: sourceReq });
+		const expectedReq = sourceReq.clone();
+		expectedReq.headers.append("x-auth-token", validSecrets.secretKey);
+		expect(updatedReq).toMatchObject(expectedReq);
+	});
+	it("throws an exception for invalid secrets", () => {
+		const invalidSecrets = {
+			accessKey: "",
+			secretKey: ""
+		};
+		expect(() => authenticateWithSecrets(invalidSecrets)({ request: sourceReq })).toThrow();
+	});
+});
+//#endregion

package/dist/scw/__tests__/client-ini-factory.test.js

@@ -0,0 +1,220 @@
+import { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withLegacyInterceptors, withProfile, withUserAgent, withUserAgentSuffix } from "../client-ini-factory.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/client-ini-factory.test.ts
+var EMPTY_PROFILE = {};
+var FILLED_PROFILE = {
+	accessKey: "SCW1234567890ABCDEFG",
+	apiURL: "https://api.example.com",
+	defaultOrganizationId: "a8f9d4ab-dda4-4b9d-ab77-0a8c59a246e9",
+	defaultProjectId: "d67e2125-a1ee-4056-9f7a-ab855be03d07",
+	defaultRegion: "fr-par",
+	defaultZone: "fr-par-3",
+	secretKey: "3aef5281-13eb-4705-b858-eb64dd5da24c"
+};
+var DEFAULT_SETTINGS = {
+	apiURL: "https://api.scaleway.com",
+	defaultOrganizationId: "bd61983a-e4b5-4c6b-a841-07bc44037b5a",
+	defaultPageSize: 10,
+	defaultProjectId: "43f42be7-ea3d-4148-889c-3ad4b53bddcb",
+	defaultRegion: "nl-ams",
+	defaultZone: "fr-par-1",
+	httpClient: fetch,
+	interceptors: [],
+	userAgent: "scaleway-sdk-js/v1.0.0-beta"
+};
+describe("withProfile", () => {
+	it(`doesn't modify Settings object with empty Profile object`, () => {
+		expect(withProfile(EMPTY_PROFILE)(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+		expect(withProfile({ WTF: "malicious content" })(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+		expect(withProfile({
+			apiURL: void 0,
+			defaultOrganizationId: void 0,
+			defaultPageSize: void 0,
+			defaultProjectId: void 0,
+			defaultRegion: void 0,
+			defaultZone: void 0,
+			httpClient: void 0,
+			interceptors: void 0,
+			requestInterceptors: void 0,
+			responseInterceptors: void 0,
+			userAgent: void 0
+		})(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+		expect(withProfile({
+			apiURL: null,
+			defaultOrganizationId: null,
+			defaultPageSize: null,
+			defaultProjectId: null,
+			defaultRegion: null,
+			defaultZone: null,
+			httpClient: null,
+			interceptors: null,
+			requestInterceptors: null,
+			responseInterceptors: null,
+			userAgent: null
+		})(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+		expect(withProfile({
+			apiURL: "",
+			defaultOrganizationId: "",
+			defaultPageSize: "",
+			defaultProjectId: "",
+			defaultRegion: "",
+			defaultZone: "",
+			httpClient: "",
+			interceptors: "",
+			requestInterceptors: "",
+			responseInterceptors: "",
+			userAgent: ""
+		})(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+		expect(withProfile({
+			apiURL: 0,
+			defaultOrganizationId: 0,
+			defaultPageSize: 0,
+			defaultProjectId: 0,
+			defaultRegion: 0,
+			defaultZone: 0,
+			httpClient: 0,
+			interceptors: 0,
+			requestInterceptors: 0,
+			responseInterceptors: 0,
+			userAgent: 0
+		})(DEFAULT_SETTINGS)).toStrictEqual(DEFAULT_SETTINGS);
+	});
+	it("only modifies apiURL", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			apiURL: FILLED_PROFILE.apiURL
+		};
+		expect(withProfile({ apiURL: FILLED_PROFILE.apiURL })(DEFAULT_SETTINGS)).toStrictEqual(expectedSettings);
+	});
+	it("only modifies default organization ID", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			defaultOrganizationId: FILLED_PROFILE.defaultOrganizationId
+		};
+		expect(withProfile({ defaultOrganizationId: FILLED_PROFILE.defaultOrganizationId })(DEFAULT_SETTINGS)).toStrictEqual(expectedSettings);
+	});
+	it("only modifies default project ID", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			defaultProjectId: FILLED_PROFILE.defaultProjectId
+		};
+		expect(withProfile({ defaultProjectId: FILLED_PROFILE.defaultProjectId })(DEFAULT_SETTINGS)).toStrictEqual(expectedSettings);
+	});
+	it("only modifies default region", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			defaultRegion: FILLED_PROFILE.defaultRegion
+		};
+		expect(withProfile({ defaultRegion: FILLED_PROFILE.defaultRegion })(DEFAULT_SETTINGS)).toStrictEqual(expectedSettings);
+	});
+	it("only modifies default zone", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			defaultZone: FILLED_PROFILE.defaultZone
+		};
+		expect(withProfile({ defaultZone: FILLED_PROFILE.defaultZone })(DEFAULT_SETTINGS)).toStrictEqual(expectedSettings);
+	});
+	it("modifies authentication", async () => {
+		if (!DEFAULT_SETTINGS.apiURL) throw new Error("API URL is missing");
+		const request = new Request(DEFAULT_SETTINGS.apiURL);
+		const reqInterceptor = withProfile({
+			accessKey: FILLED_PROFILE.accessKey,
+			secretKey: FILLED_PROFILE.secretKey
+		})(DEFAULT_SETTINGS).interceptors[0].request;
+		expect(reqInterceptor).toBeDefined();
+		if (reqInterceptor) {
+			const { headers } = await reqInterceptor({ request });
+			expect(headers.get("x-auth-token")).toStrictEqual(FILLED_PROFILE.secretKey);
+		}
+	});
+});
+describe("withDefaultPageSize", () => {
+	it("only modifies the default page size", () => {
+		const newDefaultPageSize = 42;
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			defaultPageSize: newDefaultPageSize
+		};
+		expect(JSON.stringify(withDefaultPageSize(newDefaultPageSize)(DEFAULT_SETTINGS))).toStrictEqual(JSON.stringify(expectedSettings));
+	});
+});
+describe("withHTTPClient", () => {
+	it("only modifies the http client", () => {
+		const newHTTPClient = () => Promise.resolve(new Response());
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			httpClient: newHTTPClient
+		};
+		expect(JSON.stringify(withHTTPClient(newHTTPClient)(DEFAULT_SETTINGS))).toStrictEqual(JSON.stringify(expectedSettings));
+	});
+});
+describe("withUserAgent", () => {
+	const defaultUserAgent = "my-source/v0.1.0";
+	it("only modifies the user agent", () => {
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			userAgent: defaultUserAgent
+		};
+		expect(JSON.stringify(withUserAgent(defaultUserAgent)(DEFAULT_SETTINGS))).toStrictEqual(JSON.stringify(expectedSettings));
+	});
+});
+describe("withUserAgentSuffix", () => {
+	it("appends to the original user agent", () => {
+		const defaultUserAgent = DEFAULT_SETTINGS.userAgent;
+		const addUserAgent = "additional-source/v1.0.0";
+		const expectedSettings = {
+			...DEFAULT_SETTINGS,
+			userAgent: `${defaultUserAgent} ${addUserAgent}`
+		};
+		expect(JSON.stringify(withUserAgentSuffix(addUserAgent)(DEFAULT_SETTINGS))).toStrictEqual(JSON.stringify(expectedSettings));
+	});
+	it("replaces the default user agent if the original one is empty", () => {
+		const newSettings = {
+			...DEFAULT_SETTINGS,
+			userAgent: ""
+		};
+		const addUserAgent = "additional-source/v1.0.0";
+		const expectedSettings = {
+			...newSettings,
+			userAgent: addUserAgent
+		};
+		expect(JSON.stringify(withUserAgentSuffix(addUserAgent)(newSettings))).toStrictEqual(JSON.stringify(expectedSettings));
+	});
+});
+describe("withAdditionalInterceptors", () => {
+	it("appends interceptors to existing ones", () => {
+		const oneInterProfile = withAdditionalInterceptors([{ request: ({ request }) => request }])(DEFAULT_SETTINGS);
+		const twoInterProfile = withAdditionalInterceptors([{
+			response: ({ response }) => response,
+			responseError: (err) => err
+		}])(oneInterProfile);
+		expect(twoInterProfile.interceptors.length).toEqual(2);
+		expect(twoInterProfile.interceptors[1].response).toBeDefined();
+		expect(twoInterProfile.interceptors[1].responseError).toBeDefined();
+		expect(twoInterProfile.interceptors[1].request).toBeUndefined();
+	});
+});
+describe("withLegacyInterceptors", () => {
+	it("changes nothing if no legacy interceptor", () => {
+		expect(JSON.stringify(withLegacyInterceptors()(DEFAULT_SETTINGS))).toStrictEqual(JSON.stringify(DEFAULT_SETTINGS));
+	});
+	it("appends the legacy request and response interceptors", () => {
+		const legacyInterceptors = (obj) => ({
+			...obj,
+			requestInterceptors: [({ request }) => request, ({ request }) => request],
+			responseInterceptors: [({ response }) => response]
+		});
+		expect(withLegacyInterceptors()(legacyInterceptors(DEFAULT_SETTINGS)).interceptors.length).toBe(3);
+		const legacyReqInterceptors = (obj) => ({
+			...obj,
+			requestInterceptors: [({ request }) => request, ({ request }) => request]
+		});
+		expect(withLegacyInterceptors()(legacyReqInterceptors(DEFAULT_SETTINGS)).interceptors.length).toBe(2);
+		const legacyResInterceptors = (obj) => ({
+			...obj,
+			responseInterceptors: [({ response }) => response]
+		});
+		expect(withLegacyInterceptors()(legacyResInterceptors(DEFAULT_SETTINGS)).interceptors.length).toBe(1);
+	});
+});
+//#endregion

package/dist/scw/__tests__/client-ini-profile.test.js

@@ -0,0 +1,70 @@
+import { assertValidAuthenticationSecrets, hasAuthenticationSecrets } from "../client-ini-profile.js";
+import { describe, expect, it, test } from "vitest";
+//#region src/scw/__tests__/client-ini-profile.test.ts
+describe("hasAuthenticationSecrets", () => {
+	it("confirms a non-empty payload", () => {
+		expect(hasAuthenticationSecrets({
+			accessKey: "any-string",
+			secretKey: "any-string"
+		})).toBeTruthy();
+	});
+	it("rejects payload with empty access or secret", () => {
+		expect(hasAuthenticationSecrets({
+			accessKey: "",
+			secretKey: ""
+		})).toBeFalsy();
+		expect(hasAuthenticationSecrets({
+			accessKey: "",
+			secretKey: "any-string"
+		})).toBeFalsy();
+		expect(hasAuthenticationSecrets({
+			accessKey: "any-string",
+			secretKey: ""
+		})).toBeFalsy();
+	});
+});
+describe("assertValidAuthenticationSecrets", () => {
+	it(`doesn't throw for valid secrets`, () => {
+		expect(() => {
+			assertValidAuthenticationSecrets({
+				accessKey: "SCW01234567890123456",
+				secretKey: "e4b83996-4c60-449a-98d2-38f5de7b4e6b"
+			});
+		}).not.toThrow();
+	});
+	test.each([
+		{
+			accessKey: "",
+			secretKey: ""
+		},
+		{
+			accessKey: "SCW01234567890123456",
+			secretKey: ""
+		},
+		{
+			accessKey: "",
+			secretKey: "e4b83996-4c60-449a-98d2-38f5de7b4e6b"
+		}
+	])("%s throws for empty keys", (value) => {
+		expect(() => {
+			assertValidAuthenticationSecrets(value);
+		}).toThrow(/* @__PURE__ */ new Error(`Invalid secrets, accessKey & secretKey must be defined. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`));
+	});
+	it(`throws for invalid accessKey`, () => {
+		expect(() => {
+			assertValidAuthenticationSecrets({
+				accessKey: "SCW0123",
+				secretKey: "e4b83996-4c60-449a-98d2-38f5de7b4e6b"
+			});
+		}).toThrow(/* @__PURE__ */ new Error(`Invalid access key format 'SCW0123', expected SCWXXXXXXXXXXXXXXXXX format. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`));
+	});
+	it(`throws for invalid secretKey`, () => {
+		expect(() => {
+			assertValidAuthenticationSecrets({
+				accessKey: "SCW01234567890123456",
+				secretKey: "e4b83996-4c60-449a-98d2"
+			});
+		}).toThrow(/* @__PURE__ */ new Error(`Invalid secret key format 'e4b83996-4c60-449a-98d2', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`));
+	});
+});
+//#endregion

package/dist/scw/__tests__/client-settings.test.js

@@ -0,0 +1,51 @@
+import { assertValidSettings } from "../client-settings.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/client-settings.test.ts
+var VALID_SETTINGS = {
+	apiURL: "https://api.scaleway.com",
+	defaultOrganizationId: "1f1ca70e-a7d4-4061-8495-09e17e69a0dc",
+	defaultPageSize: 10,
+	defaultProjectId: "ca69720b-8a3d-4295-8f6d-87257f0474b4",
+	defaultRegion: "fr-par",
+	defaultZone: "fr-par-1",
+	httpClient: fetch,
+	interceptors: [],
+	requestInterceptors: [],
+	responseInterceptors: [],
+	userAgent: "scaleway-sdk-js/v1.0.0-beta"
+};
+var INVALID_SETTINGS_LIST = [
+	{ apiURL: "https://api.scaleway.com/" },
+	{ apiURL: "ftp://api.scaleway.com" },
+	{ defaultZone: "fr-par-0" },
+	{ defaultZone: "fr-par" },
+	{ defaultRegion: "fr-par-1" },
+	{ httpClient: "str-client" },
+	{ defaultOrganizationId: "" },
+	{ defaultOrganizationId: "not-a-uuid-v4" },
+	{ defaultProjectId: "" },
+	{ defaultProjectId: "not-a-uuid-v4" },
+	{ defaultPageSize: 0 },
+	{ defaultPageSize: -1 },
+	{ defaultPageSize: "42" },
+	{ userAgent: null }
+];
+describe("assertValidSettings", () => {
+	it("accepts valid Settings object", () => {
+		expect(() => {
+			assertValidSettings(VALID_SETTINGS);
+		}).not.toThrow();
+	});
+	for (const obj of INVALID_SETTINGS_LIST) {
+		const newProfile = {
+			...VALID_SETTINGS,
+			...obj
+		};
+		it(`rejects invalid Settings object ${JSON.stringify(obj)}`, () => {
+			expect(() => {
+				assertValidSettings(newProfile);
+			}).toThrow();
+		});
+	}
+});
+//#endregion

package/dist/scw/__tests__/client.test.js

@@ -0,0 +1,59 @@
+import { withProfile } from "../client-ini-factory.js";
+import { createAdvancedClient, createClient } from "../client.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/client.test.ts
+var withApiURL = (apiURL) => (obj) => ({
+	...obj,
+	apiURL
+});
+var withPassthroughFetch = (res) => (obj) => ({
+	...obj,
+	httpClient: () => Promise.resolve(new Response(res))
+});
+describe("createAdvancedClient", () => {
+	it("initializes without throwing", () => {
+		expect(() => {
+			createAdvancedClient();
+		}).not.toThrow();
+	});
+	it("contains override from withProfile", () => {
+		expect(createAdvancedClient(withProfile({ defaultRegion: "nl-ams" })).settings.defaultRegion).toBe("nl-ams");
+	});
+	it("contains override from withProfile with authentication", () => {
+		expect(createAdvancedClient(withProfile({
+			accessKey: "SCW1234567890ABCDEFG",
+			secretKey: "3aef5281-13eb-4705-b858-eb64dd5da24c"
+		})).settings.interceptors.length).toBe(1);
+	});
+	it("does not mutate default requestInterceptors", () => {
+		let client = createAdvancedClient(withProfile({
+			accessKey: "SCW1234567890ABCDEFG",
+			secretKey: "3aef5281-13eb-4705-b858-eb64dd5da24c"
+		}));
+		client = createAdvancedClient(withProfile({
+			accessKey: "SCW1234567890ABCDEFG",
+			secretKey: "3aef5281-13eb-4705-b858-eb64dd5da24c"
+		}));
+		expect(client.settings.interceptors.length).toBe(1);
+	});
+	it("contains override from custom option", () => {
+		const betaApiRoot = "https://api-beta.scaleway.com";
+		expect(createAdvancedClient(withApiURL(betaApiRoot)).settings.apiURL).toBe(betaApiRoot);
+	});
+	it("contains override of httpClient", () => {
+		return expect(createAdvancedClient(withPassthroughFetch("hello world")).settings.httpClient("any-url").then((obj) => obj.text())).resolves.toBe("hello world");
+	});
+});
+describe("createClient", () => {
+	it("initializes without throwing", () => {
+		expect(() => {
+			createClient();
+		}).not.toThrow();
+	});
+	it("contains proper default values", () => {
+		const client = createAdvancedClient();
+		expect(client.settings.apiURL).toBe("https://api.scaleway.com");
+		expect(client.settings.userAgent.startsWith("scaleway-sdk-js/")).toBe(true);
+	});
+});
+//#endregion

package/dist/scw/__tests__/custom-marshalling.test.js

@@ -0,0 +1,168 @@
+import { Decimal } from "../custom-types.js";
+import { marshalMoney, marshalScwFile, marshalTimeSeries, marshalTimeSeriesPoint, unmarshalDecimal, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from "../custom-marshalling.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/custom-marshalling.test.ts
+describe("unmarshalMoney", () => {
+	it("returns the proper object", () => {
+		expect(unmarshalMoney({
+			currency_code: "EUR",
+			nanos: 0,
+			units: 42
+		})).toStrictEqual({
+			currencyCode: "EUR",
+			nanos: 0,
+			units: 42
+		});
+	});
+	it("throws for invalid input", () => {
+		expect(() => {
+			unmarshalMoney(null);
+		}).toThrow();
+	});
+});
+describe("unmarshalServiceInfo", () => {
+	it("returns the proper object", () => {
+		expect(unmarshalServiceInfo({
+			description: "Service description",
+			documentation_url: "https://",
+			name: "TheService",
+			version: "v1"
+		})).toStrictEqual({
+			description: "Service description",
+			documentationUrl: "https://",
+			name: "TheService",
+			version: "v1"
+		});
+	});
+	it("throws for invalid input", () => {
+		expect(() => {
+			unmarshalServiceInfo(null);
+		}).toThrow();
+	});
+});
+describe("unmarshalScwFile", () => {
+	it("returns the proper object", () => {
+		expect(unmarshalScwFile({
+			content: "eyJoZWxsbyI6IndvcmxkIn0=",
+			content_type: "text/plain",
+			name: "filename"
+		})).toStrictEqual({
+			content: "eyJoZWxsbyI6IndvcmxkIn0=",
+			contentType: "text/plain",
+			name: "filename"
+		});
+	});
+	it("throws for invalid input", () => {
+		expect(() => {
+			unmarshalScwFile(null);
+		}).toThrow();
+	});
+});
+describe("unmarshalTimeSeriesPoint", () => {
+	it("returns the proper object", () => {
+		expect(unmarshalTimeSeriesPoint(["2019-08-08T15:00:00.000Z", 42])).toStrictEqual({
+			timestamp: /* @__PURE__ */ new Date("2019-08-08T15:00:00.000Z"),
+			value: 42
+		});
+	});
+	it("throws for invalid input", () => {
+		expect(() => {
+			unmarshalTimeSeriesPoint(null);
+		}).toThrow();
+	});
+});
+describe("unmarshalTimeSeries", () => {
+	it("returns the proper object", () => {
+		expect(unmarshalTimeSeries({
+			metadata: { mattress: "cloud" },
+			name: "sleep",
+			points: [["2019-08-08T15:00:00.000Z", 8]]
+		})).toStrictEqual({
+			metadata: { mattress: "cloud" },
+			name: "sleep",
+			points: [{
+				timestamp: /* @__PURE__ */ new Date("2019-08-08T15:00:00.000Z"),
+				value: 8
+			}]
+		});
+	});
+	it("throws for invalid input", () => {
+		expect(() => {
+			unmarshalTimeSeries(null);
+		}).toThrow();
+	});
+});
+describe("unmarshalDecimal", () => {
+	it("returns the proper object", () => {
+		const decimal = unmarshalDecimal({ value: "0.01" });
+		expect(decimal).toBeInstanceOf(Decimal);
+		expect(decimal?.toString()).toStrictEqual("0.01");
+	});
+	it("throws for invalid input", () => {
+		expect(unmarshalDecimal(null)).toBeNull();
+		expect(() => {
+			unmarshalDecimal({});
+		}).toThrow();
+		expect(() => {
+			unmarshalDecimal({ value: null });
+		}).toThrow();
+		expect(() => {
+			unmarshalDecimal({ value: .02 });
+		}).toThrow();
+	});
+});
+describe("marshalScwFile", () => {
+	it("returns a the proper object", () => expect(marshalScwFile({
+		content: "eyJoZWxsbyI6IndvcmxkIn0=",
+		contentType: "text/plain",
+		name: "filename"
+	})).toStrictEqual({
+		content: "eyJoZWxsbyI6IndvcmxkIn0=",
+		content_type: "text/plain",
+		name: "filename"
+	}));
+});
+describe("marshalMoney", () => {
+	it("returns the proper object", () => {
+		expect(marshalMoney({
+			currencyCode: "EUR",
+			nanos: 0,
+			units: 42
+		})).toStrictEqual({
+			currency_code: "EUR",
+			nanos: 0,
+			units: 42
+		});
+	});
+});
+describe("marshalTimeSeriesPoint", () => {
+	it("returns the proper object", () => {
+		expect(marshalTimeSeriesPoint({
+			timestamp: /* @__PURE__ */ new Date("2019-08-08T15:00:00.000Z"),
+			value: 42
+		})).toStrictEqual({
+			timestamp: "2019-08-08T15:00:00.000Z",
+			value: 42
+		});
+	});
+});
+describe("marshalTimeSeries", () => {
+	it("returns the proper object", () => {
+		expect(marshalTimeSeries({
+			metadata: { mattress: "cloud" },
+			name: "sleep",
+			points: [{
+				timestamp: /* @__PURE__ */ new Date("2019-08-08T15:00:00.000Z"),
+				value: 8
+			}]
+		})).toStrictEqual({
+			metadata: { mattress: "cloud" },
+			name: "sleep",
+			points: [{
+				timestamp: "2019-08-08T15:00:00.000Z",
+				value: 8
+			}]
+		});
+	});
+});
+//#endregion

package/dist/scw/api.js

@@ -1,3 +1,4 @@
+//#region src/scw/api.ts
 /**
 * Abstract class to instantiate API from a {@link Client}.
 *
@@ -8,4 +9,5 @@ var API = class {
 		this.client = client;
 	}
 };
+//#endregion
 export { API };