@trayio/commons 3.8.1-beta → 3.9.1

package/dist/buffer/BufferExtensions.js

@@ -22,47 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferExtensions = void 0;
 const stream_1 = require("stream");
 const TE = __importStar(require("fp-ts/TaskEither"));
 exports.BufferExtensions = {
-    readableToArrayBuffer: (stream) => TE.tryCatch(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, e_1, _b, _c;
+    readableToArrayBuffer: (stream) => TE.tryCatch(async () => {
         const chunks = [];
-        try {
-            for (var _d = true, stream_2 = __asyncValues(stream), stream_2_1; stream_2_1 = yield stream_2.next(), _a = stream_2_1.done, !_a; _d = true) {
-                _c = stream_2_1.value;
-                _d = false;
-                const chunk = _c;
-                chunks.push(chunk);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = stream_2.return)) yield _b.call(stream_2);
-            }
-            finally { if (e_1) throw e_1.error; }
+        for await (const chunk of stream) {
+            chunks.push(chunk);
         }
         const buffer = Buffer.concat(chunks);
         return Uint8Array.from(buffer).buffer;
-    }), (error) => error),
+    }, (error) => error),
     arrayBufferToReadable: (arrayBuffer) => stream_1.Readable.from(Buffer.from(arrayBuffer)),
 };

package/dist/buffer/BufferExtensions.unit.test.js

@@ -22,26 +22,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const E = __importStar(require("fp-ts/Either"));
 const util_1 = require("util");
 const BufferExtensions_1 = require("./BufferExtensions");
 describe('Buffer Tests', () => {
-    it('should convert a buffer to a stream, then stream back to a buffer', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should convert a buffer to a stream, then stream back to a buffer', async () => {
         const readableStream = BufferExtensions_1.BufferExtensions.arrayBufferToReadable(new util_1.TextEncoder().encode('test').buffer);
-        const bufferResult = yield BufferExtensions_1.BufferExtensions.readableToArrayBuffer(readableStream)();
+        const bufferResult = await BufferExtensions_1.BufferExtensions.readableToArrayBuffer(readableStream)();
         const buffer = E.getOrElse((error) => {
             throw new Error(error.message);
         })(bufferResult);
         expect(buffer).toEqual(new util_1.TextEncoder().encode('test').buffer);
-    }));
+    });
 });

package/dist/codec/CompositeCodec.js

@@ -27,6 +27,8 @@ exports.CompositeCodec = void 0;
 const E = __importStar(require("fp-ts/lib/Either"));
 const function_1 = require("fp-ts/function");
 class CompositeCodec {
+    innerCodec;
+    outerCodec;
     static fromCodecs(innerCodec, outerCodec) {
         return new CompositeCodec(innerCodec, outerCodec);
     }

package/dist/codec/RemoveNullValuesCodec.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveNullValuesCodec = void 0;
 const E = __importStar(require("fp-ts/lib/Either"));
 class RemoveNullValuesCodec {
+    static instance = new RemoveNullValuesCodec();
     encode(value) {
         return this.removeNullValuesIfPresent(value);
     }
@@ -62,15 +63,14 @@ class RemoveNullValuesCodec {
             }
             if (this.isObject(propertyValue)) {
                 const nestedObject = this.removeNullFromObjectIfPresent(propertyValue);
-                return Object.assign(Object.assign({}, acc), { [key]: nestedObject });
+                return { ...acc, [key]: nestedObject };
             }
             if (Array.isArray(propertyValue)) {
                 const nestedArray = this.removeNullFromArrayIfPresent(propertyValue);
-                return Object.assign(Object.assign({}, acc), { [key]: nestedArray });
+                return { ...acc, [key]: nestedArray };
             }
-            return Object.assign(Object.assign({}, acc), { [key]: propertyValue });
+            return { ...acc, [key]: propertyValue };
         }, {});
     }
 }
 exports.RemoveNullValuesCodec = RemoveNullValuesCodec;
-RemoveNullValuesCodec.instance = new RemoveNullValuesCodec();

package/dist/codec/TypeCodec.js

@@ -36,6 +36,14 @@ class TypeCodec {
     static fromDescriptor(descriptor) {
         return new TypeCodec(descriptor);
     }
+    static undefined = TypeCodec.fromDescriptor(t.undefined);
+    static unknown = TypeCodec.fromDescriptor(t.unknown);
+    static emptyRecord = TypeCodec.fromDescriptor(t.type({}));
+    static stringRecord = TypeCodec.fromDescriptor(t.record(t.string, t.string));
+    // Added support for partial records as IO-TS does not support them
+    // https://github.com/gcanti/io-ts/issues/429#issuecomment-862472408
+    static partialRecord = (k, type) => t.partial((0, Record_1.map)(() => type)(k.keys));
+    descriptor;
     constructor(descriptor) {
         this.descriptor = descriptor;
     }
@@ -49,10 +57,3 @@ class TypeCodec {
     }
 }
 exports.TypeCodec = TypeCodec;
-TypeCodec.undefined = TypeCodec.fromDescriptor(t.undefined);
-TypeCodec.unknown = TypeCodec.fromDescriptor(t.unknown);
-TypeCodec.emptyRecord = TypeCodec.fromDescriptor(t.type({}));
-TypeCodec.stringRecord = TypeCodec.fromDescriptor(t.record(t.string, t.string));
-// Added support for partial records as IO-TS does not support them
-// https://github.com/gcanti/io-ts/issues/429#issuecomment-862472408
-TypeCodec.partialRecord = (k, type) => t.partial((0, Record_1.map)(() => type)(k.keys));

package/dist/file/FakeFileStorage.js

@@ -29,6 +29,7 @@ const E = __importStar(require("fp-ts/Either"));
 const function_1 = require("fp-ts/lib/function");
 const stream_1 = require("stream");
 class FakeFileStorage {
+    files;
     constructor() {
         this.files = new Map();
     }

package/dist/file/FileStorage.abstract.test.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileStorageTest = void 0;
 const E = __importStar(require("fp-ts/Either"));
@@ -42,7 +33,7 @@ const fileStorageTest = (fileStorage) => {
     describe('FileStorage Tests', () => {
         describe('Writing a file', () => {
             describe("when it's successful", () => {
-                it('should write a file, read the file then delete the file', () => __awaiter(void 0, void 0, void 0, function* () {
+                it('should write a file, read the file then delete the file', async () => {
                     const serialization = new JsonSerialization_1.JsonSerialization();
                     const fileContent = { test: 'someValue' };
                     const readableStream = new stream_1.Readable({
@@ -59,9 +50,9 @@ const fileStorageTest = (fileStorage) => {
                         },
                         content: readableStream,
                     };
-                    const writtenFile = yield fileStorage.write(file, O.none)();
+                    const writtenFile = await fileStorage.write(file, O.none)();
                     expect(writtenFile).toEqual(E.right(file));
-                    const sharedUrl = yield fileStorage.getSharedUrl(file.key)();
+                    const sharedUrl = await fileStorage.getSharedUrl(file.key)();
                     expect(sharedUrl).toEqual(E.right(expect.objectContaining({
                         url: expect.any(String),
                     })));
@@ -70,12 +61,12 @@ const fileStorageTest = (fileStorage) => {
                             expect(sharedUrl.right.expires).toEqual(expect.any(Number));
                         }
                     }
-                    const read = yield fileStorage.read(file.key)();
+                    const read = await fileStorage.read(file.key)();
                     const readResponse = E.getOrElse(() => {
                         throw new Error('Expected right');
                     })(read);
                     let data = '';
-                    yield new Promise((resolve) => {
+                    await new Promise((resolve) => {
                         readResponse.content.on('data', (chunk) => {
                             data += chunk;
                         });
@@ -88,20 +79,20 @@ const fileStorageTest = (fileStorage) => {
                         throw new Error('failed to deserialise stream contents');
                     }
                     expect(deserializedData.right).toStrictEqual(fileContent);
-                    const deleted = yield fileStorage.delete(file.key)();
+                    const deleted = await fileStorage.delete(file.key)();
                     expect(deleted).toEqual(E.right(undefined));
-                }));
+                });
             });
         });
         describe('Reading a file', () => {
             describe('when the file does not exist', () => {
-                it('should return does not exist error', () => __awaiter(void 0, void 0, void 0, function* () {
-                    const read = yield fileStorage.read(`fail_test-${(0, uuid_1.v4)()}.zip`)();
+                it('should return does not exist error', async () => {
+                    const read = await fileStorage.read(`fail_test-${(0, uuid_1.v4)()}.zip`)();
                     if (E.isRight(read)) {
                         throw new Error('Expected left');
                     }
                     expect(read.left).toBeInstanceOf(Error);
-                }));
+                });
             });
         });
     });

package/dist/file/NodeFsFileStorage.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeFsFileStorage = void 0;
 const fs = __importStar(require("fs/promises"));
@@ -39,6 +30,7 @@ const TE = __importStar(require("fp-ts/lib/TaskEither"));
 const function_1 = require("fp-ts/lib/function");
 const Task_1 = require("../task/Task");
 class NodeFsFileStorage {
+    basePath;
     constructor(basePath = '/tmp') {
         this.basePath = basePath;
     }
@@ -49,23 +41,21 @@ class NodeFsFileStorage {
     }
     read(key, name = key) {
         const filePath = `${this.basePath}/${key}`;
-        return TE.tryCatch(() => __awaiter(this, void 0, void 0, function* () {
-            const fileHandle = yield fs.open(filePath, 'r');
-            const stat = yield fs.stat(filePath);
+        return TE.tryCatch(async () => {
+            const fileHandle = await fs.open(filePath, 'r');
+            const stat = await fs.stat(filePath);
             const stream = fileHandle.createReadStream();
             const metadata = {
                 name,
                 size: stat.size,
             };
             return { metadata, key: filePath, content: stream };
-        }), (reason) => new Error(String(reason)));
+        }, (reason) => new Error(String(reason)));
     }
     getSharedUrl(key) {
         const filePath = `${this.basePath}/${key}`;
-        return TE.tryCatch(() => __awaiter(this, void 0, void 0, function* () {
-            return ({
-                url: path.resolve(filePath),
-            });
+        return TE.tryCatch(async () => ({
+            url: path.resolve(filePath),
         }), (reason) => new Error(String(reason)));
     }
     delete(key) {

package/dist/http/Http.js

@@ -63,5 +63,5 @@ exports.HttpHeaders = {
 exports.serializationFormatToHttpContentType = {
     [Serialization_1.SerializationFormat.Json]: HttpContentType.Json,
 };
-const isMultiPartBody = (body) => (body === null || body === void 0 ? void 0 : body.files) !== undefined;
+const isMultiPartBody = (body) => body?.files !== undefined;
 exports.isMultiPartBody = isMultiPartBody;

package/dist/http/HttpClient.abstract.test.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -77,35 +68,33 @@ function httpClientTest(httpClient) {
         const serializedResponse = (0, function_1.pipe)(E.right(responseCodec.encode(response)), E.map((encodedResponse) => serialization.serialize(encodedResponse)), E.getOrElse(() => (new util_1.TextEncoder().encode('Error serializing value').buffer)));
         httpResponse.end(Buffer.from(serializedResponse));
     }
-    function processHttpRequest(requestCodec, responseCodec, httpRequest, httpResponse, process, isMultiPartBody = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isMultiPartBody) {
-                const form = (0, formidable_1.default)({});
-                let fields;
-                let files;
-                try {
-                    [fields, files] = yield form.parse(httpRequest);
-                }
-                catch (err) {
-                    console.error(err);
-                    return;
-                }
-                const input = {
-                    fields: flattenFields(fields),
-                    files: flattenFiles(files),
-                };
-                const response = (0, function_1.pipe)(requestCodec.decode(input), E.map(process), E.map((result) => new util_1.TextEncoder().encode(JSON.stringify(responseCodec.encode(result))).buffer), E.getOrElse(() => new util_1.TextEncoder().encode('Error serializing value').buffer));
-                httpResponse.end(Buffer.from(response));
+    async function processHttpRequest(requestCodec, responseCodec, httpRequest, httpResponse, process, isMultiPartBody = false) {
+        if (isMultiPartBody) {
+            const form = (0, formidable_1.default)({});
+            let fields;
+            let files;
+            try {
+                [fields, files] = await form.parse(httpRequest);
             }
-            const body = [];
-            httpRequest.on('data', (chunk) => {
-                body.push(chunk);
-            });
-            httpRequest.on('end', () => {
-                const buffer = Buffer.concat(body);
-                const response = (0, function_1.pipe)(serialization.deserialize(buffer), E.chain((encodedRequest) => requestCodec.decode(encodedRequest)), E.map(process), E.map((result) => responseCodec.encode(result)), E.map((encodedResult) => serialization.serialize(encodedResult)), E.getOrElse(() => (new util_1.TextEncoder().encode('Error serializing value').buffer)));
-                httpResponse.end(Buffer.from(response));
-            });
+            catch (err) {
+                console.error(err);
+                return;
+            }
+            const input = {
+                fields: flattenFields(fields),
+                files: flattenFiles(files),
+            };
+            const response = (0, function_1.pipe)(requestCodec.decode(input), E.map(process), E.map((result) => new util_1.TextEncoder().encode(JSON.stringify(responseCodec.encode(result))).buffer), E.getOrElse(() => new util_1.TextEncoder().encode('Error serializing value').buffer));
+            httpResponse.end(Buffer.from(response));
+        }
+        const body = [];
+        httpRequest.on('data', (chunk) => {
+            body.push(chunk);
+        });
+        httpRequest.on('end', () => {
+            const buffer = Buffer.concat(body);
+            const response = (0, function_1.pipe)(serialization.deserialize(buffer), E.chain((encodedRequest) => requestCodec.decode(encodedRequest)), E.map(process), E.map((result) => responseCodec.encode(result)), E.map((encodedResult) => serialization.serialize(encodedResult)), E.getOrElse(() => (new util_1.TextEncoder().encode('Error serializing value').buffer)));
+            httpResponse.end(Buffer.from(response));
         });
     }
     const flattenFields = (fields) => {
@@ -118,7 +107,7 @@ function httpClientTest(httpClient) {
                 flattenedFields[key] = value.join(',');
             }
             else {
-                flattenedFields[key] = value !== null && value !== void 0 ? value : '';
+                flattenedFields[key] = value ?? '';
             }
         });
         return flattenedFields;
@@ -138,19 +127,15 @@ function httpClientTest(httpClient) {
         });
         return flattenedFiles;
     };
-    const convertFormidableFileToTrayFile = (file) => {
-        var _a;
-        return ({
-            key: file.newFilename,
-            metadata: {
-                name: (_a = file.originalFilename) !== null && _a !== void 0 ? _a : '',
-                size: file.size,
-            },
-            content: stream_1.Readable.from(file.filepath),
-        });
-    };
-    const requestListener = (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    const convertFormidableFileToTrayFile = (file) => ({
+        key: file.newFilename,
+        metadata: {
+            name: file.originalFilename ?? '',
+            size: file.size,
+        },
+        content: stream_1.Readable.from(file.filepath),
+    });
+    const requestListener = async (req, res) => {
         if (req.method === 'GET' && typeof req.headers['error'] === 'string') {
             const errorCode = +req.headers['error'];
             res.writeHead(errorCode, {
@@ -171,31 +156,31 @@ function httpClientTest(httpClient) {
             sendHttpResponse(res, response, testResponseCodec);
         }
         else if (req.method === 'POST' &&
-            ((_a = req.headers['content-type']) === null || _a === void 0 ? void 0 : _a.includes(Http_1.HttpContentType.MultipartRequestBody))) {
+            req.headers['content-type']?.includes(Http_1.HttpContentType.MultipartRequestBody)) {
             res.writeHead(200, { [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json });
-            yield processHttpRequest(testMultiPartBodyTypeCodec, testMultiPartBodyTypeCodec, req, res, (input) => input, true);
+            await processHttpRequest(testMultiPartBodyTypeCodec, testMultiPartBodyTypeCodec, req, res, (input) => input, true);
         }
         else {
             const customHeader = req.headers['x-custom-header'];
             res.writeHead(200, { [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json });
-            yield processHttpRequest(testInputCodec, testResponseCodec, req, res, (input) => ({
+            await processHttpRequest(testInputCodec, testResponseCodec, req, res, (input) => ({
                 strField: customHeader,
                 intField: input.inputField,
             }));
         }
-    });
+    };
     const host = 'localhost';
     const port = 8000; // TODO: Get random port
     const baseUrl = `http://${host}:${port}`;
     const server = (0, http_1.createServer)(requestListener);
     describe('HttpClient Test', () => {
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield new Promise((resolve) => {
+        beforeAll(async () => {
+            await new Promise((resolve) => {
                 server.listen(port, host, resolve);
             });
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield new Promise((resolve, reject) => {
+        });
+        afterAll(async () => {
+            await new Promise((resolve, reject) => {
                 server.close((error) => {
                     if (error) {
                         reject(error);
@@ -205,9 +190,9 @@ function httpClientTest(httpClient) {
                     }
                 });
             });
-        }));
-        test('should send a GET request', () => __awaiter(this, void 0, void 0, function* () {
-            const response = yield httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
+        });
+        test('should send a GET request', async () => {
+            const response = await httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
                 headers: { 'x-custom-header': 'customVal' },
                 pathParams: {},
                 queryString: {},
@@ -218,14 +203,14 @@ function httpClientTest(httpClient) {
                 intField: 123,
             };
             const result = (0, function_1.pipe)(response, TE.fromEither, TE.chain((httpResponse) => BufferExtensions_1.BufferExtensions.readableToArrayBuffer(httpResponse.body)), TE.match((error) => E.left(error), (buffer) => (0, function_1.pipe)(serialization.deserialize(buffer), E.chain((encoded) => testResponseCodec.decode(encoded)))));
-            const resultE = yield result();
+            const resultE = await result();
             expect(resultE).toStrictEqual(E.right(testValue));
-        }));
-        test('should send a POST request', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        test('should send a POST request', async () => {
             const testInput = {
                 inputField: 321,
             };
-            const response = yield (0, function_1.pipe)((0, Task_1.createTaskEitherFromEither)(E.right(testInputCodec.encode(testInput))), TE.map((encoded) => serialization.serialize(encoded)), TE.chain((serializedInput) => httpClient.execute(Http_1.HttpMethod.Post, baseUrl, {
+            const response = await (0, function_1.pipe)((0, Task_1.createTaskEitherFromEither)(E.right(testInputCodec.encode(testInput))), TE.map((encoded) => serialization.serialize(encoded)), TE.chain((serializedInput) => httpClient.execute(Http_1.HttpMethod.Post, baseUrl, {
                 headers: {
                     'x-custom-header': 'customVal',
                 },
@@ -238,20 +223,20 @@ function httpClientTest(httpClient) {
                 intField: 321,
             };
             const result = (0, function_1.pipe)(response, TE.fromEither, TE.chain((httpResponse) => BufferExtensions_1.BufferExtensions.readableToArrayBuffer(httpResponse.body)), TE.match((error) => E.left(error), (buffer) => (0, function_1.pipe)(serialization.deserialize(buffer), E.chain((encoded) => testResponseCodec.decode(encoded)))));
-            const resultE = yield result();
+            const resultE = await result();
             expect(resultE).toStrictEqual(E.right(testValue));
-        }));
-        test('should send a POST request with multipart body', () => __awaiter(this, void 0, void 0, function* () {
-            yield fileStorage.delete('file1')();
-            yield fileStorage.delete('file2')();
-            const file1 = yield fileStorage.write({
+        });
+        test('should send a POST request with multipart body', async () => {
+            await fileStorage.delete('file1')();
+            await fileStorage.delete('file2')();
+            const file1 = await fileStorage.write({
                 key: 'file1',
                 metadata: {
                     name: 'file1',
                 },
                 content: stream_1.Readable.from('file 1 content'),
             })();
-            const file2 = yield fileStorage.write({
+            const file2 = await fileStorage.write({
                 key: 'file2',
                 metadata: {
                     name: 'file2',
@@ -286,7 +271,7 @@ function httpClientTest(httpClient) {
                     },
                 },
             };
-            const response = yield httpClient.execute(Http_1.HttpMethod.Post, baseUrl, {
+            const response = await httpClient.execute(Http_1.HttpMethod.Post, baseUrl, {
                 headers: {
                     'x-custom-header': 'customVal',
                     'content-type': Http_1.HttpContentType.MultipartRequestBody,
@@ -296,7 +281,7 @@ function httpClientTest(httpClient) {
                 body: testInput,
             })();
             const result = (0, function_1.pipe)(response, TE.fromEither, TE.chain((httpResponse) => BufferExtensions_1.BufferExtensions.readableToArrayBuffer(httpResponse.body)), TE.match((error) => E.left(error), (buffer) => (0, function_1.pipe)(serialization.deserialize(buffer), E.chain((encoded) => testMultiPartBodyTypeCodec.decode(encoded)))));
-            const resultE = yield result();
+            const resultE = await result();
             expect(resultE).toEqual(E.right(expect.objectContaining({
                 fields: testInput.fields,
                 files: expect.objectContaining({
@@ -314,9 +299,9 @@ function httpClientTest(httpClient) {
                     }),
                 }),
             })));
-        }));
-        test('should parse an internal error response', () => __awaiter(this, void 0, void 0, function* () {
-            const response = yield httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
+        });
+        test('should parse an internal error response', async () => {
+            const response = await httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
                 headers: { error: '500' },
                 pathParams: {},
                 queryString: {},
@@ -328,12 +313,12 @@ function httpClientTest(httpClient) {
             if (E.isLeft(response)) {
                 throw response.left;
             }
-            const responseBodyE = yield BufferExtensions_1.BufferExtensions.readableToArrayBuffer(response.right.body)();
+            const responseBodyE = await BufferExtensions_1.BufferExtensions.readableToArrayBuffer(response.right.body)();
             expect(response.right.statusCode).toStrictEqual(500);
             expect(responseBodyE).toStrictEqual(E.right(serialization.serialize(testErrorResponseCodec.encode(testErrorResponse))));
-        }));
-        test('should parse a not found error response', () => __awaiter(this, void 0, void 0, function* () {
-            const response = yield httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
+        });
+        test('should parse a not found error response', async () => {
+            const response = await httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
                 headers: { error: '404' },
                 pathParams: {},
                 queryString: {},
@@ -345,10 +330,10 @@ function httpClientTest(httpClient) {
             if (E.isLeft(response)) {
                 throw response.left;
             }
-            const responseBodyE = yield BufferExtensions_1.BufferExtensions.readableToArrayBuffer(response.right.body)();
+            const responseBodyE = await BufferExtensions_1.BufferExtensions.readableToArrayBuffer(response.right.body)();
             expect(response.right.statusCode).toStrictEqual(404);
             expect(responseBodyE).toStrictEqual(E.right(serialization.serialize(testErrorResponseCodec.encode(testErrorResponse))));
-        }));
+        });
     });
 }
 exports.httpClientTest = httpClientTest;

package/dist/result/Result.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResultInternal = exports.Result = exports.ResultFailureError = void 0;
 const E = __importStar(require("fp-ts/Either"));
 class ResultFailureError extends Error {
+    failureCause;
     constructor(failureCause) {
         super(`Result could not be read because it is a failure: ${JSON.stringify(failureCause)}`);
         this.failureCause = failureCause;

package/dist/serialization/JsonSerialization.js

@@ -30,11 +30,9 @@ const function_1 = require("fp-ts/function");
 const Serialization_1 = require("./Serialization");
 const Try_1 = require("../try/Try");
 class JsonSerialization {
-    constructor() {
-        this.textEncoder = new util_1.TextEncoder();
-        this.textDecoder = new util_1.TextDecoder();
-        this.format = Serialization_1.SerializationFormat.Json;
-    }
+    textEncoder = new util_1.TextEncoder();
+    textDecoder = new util_1.TextDecoder();
+    format = Serialization_1.SerializationFormat.Json;
     serialize(value) {
         const json = JSON.stringify(value);
         return this.textEncoder.encode(json).buffer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/commons",
-  "version": "3.8.1-beta",
+  "version": "3.9.1",
   "description": "Extensions to the standard/core libraries and basic features",
   "exports": {
     "./*": "./dist/*.js"