@trayio/commons 0.0.1-beta

package/dist/file/NodeFsFileStorage.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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"));
+const path = __importStar(require("path"));
+const TE = __importStar(require("fp-ts/lib/TaskEither"));
+const function_1 = require("fp-ts/lib/function");
+const Task_1 = require("../task/Task");
+class NodeFsFileStorage {
+    constructor(basePath = '/tmp') {
+        this.basePath = basePath;
+    }
+    write(file) {
+        const filePath = `${this.basePath}/${file.key}`;
+        const result = (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.writeFile(filePath, file.content));
+        return (0, function_1.pipe)(result, TE.map(() => file));
+    }
+    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);
+            const stream = fileHandle.createReadStream();
+            const metadata = {
+                name,
+                size: stat.size,
+            };
+            return { metadata, key: filePath, content: stream };
+        }), (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),
+            });
+        }), (reason) => new Error(String(reason)));
+    }
+    delete(key) {
+        const filePath = `${this.basePath}/${key}`;
+        const result = (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.unlink(filePath));
+        return (0, function_1.pipe)(result, TE.map(() => undefined));
+    }
+    createDirectory(key) {
+        const filePath = `${this.basePath}/${key}`;
+        const result = (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.mkdir(filePath, { recursive: true }));
+        return (0, function_1.pipe)(result, TE.map(() => undefined));
+    }
+}
+exports.NodeFsFileStorage = NodeFsFileStorage;

package/dist/http/Http.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+import * as O from 'fp-ts/lib/Option';
+import { Readable } from 'stream';
+import { File } from '../file/File';
+import { SerializationFormat } from '../serialization/Serialization';
+export type HttpHeaderValue = string | string[];
+export type HttpHeaders = Record<string, HttpHeaderValue | HttpContentType>;
+export type HttpQueryStringSingleValue = number | string | boolean;
+export type HttpQueryStringValue = HttpQueryStringSingleValue | HttpQueryStringSingleValue[];
+export type HttpQueryString = Record<string, HttpQueryStringValue>;
+export type RegularHttpRequestBody = Readable;
+export type MultipartHttpRequestBody = {
+    fields: Record<string, string>;
+    files: Record<string, File>;
+};
+export type HttpRequestBody = RegularHttpRequestBody | MultipartHttpRequestBody;
+export type HttpRequest = {
+    headers: HttpHeaders;
+    pathParams: Record<string, string>;
+    queryString: HttpQueryString;
+    body: HttpRequestBody;
+};
+export type HttpResponse = {
+    statusCode: number;
+    headers: HttpHeaders;
+    body: Readable;
+};
+export declare enum HttpMethod {
+    Get = "GET",
+    Put = "PUT",
+    Post = "POST",
+    Patch = "PATCH",
+    Delete = "DELETE"
+}
+export declare enum HttpContentType {
+    Json = "application/json",
+    OctetStream = "application/octet-stream",
+    MultipartRequestBody = "multipart/form-data",
+    Text = "text/plain"
+}
+export declare enum HttpHeader {
+    Authorization = "Authorization",
+    ContentType = "Content-Type",
+    Impersonation = "X-Tray-Admin-Impersonate",
+    UserAgent = "User-Agent",
+    ContentLength = "Content-Length"
+}
+export interface HttpHeadersInterface {
+    get: (headers: HttpHeaders, name: string) => O.Option<HttpHeaderValue>;
+    extractBearerToken: (headers: HttpHeaders) => O.Option<string>;
+}
+export declare const HttpHeaders: HttpHeadersInterface;
+export declare const serializationFormatToHttpContentType: Record<SerializationFormat, HttpContentType>;
+export declare const isMultiPartBody: (body: HttpRequestBody) => body is MultipartHttpRequestBody;
+//# sourceMappingURL=Http.d.ts.map

package/dist/http/Http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Http.d.ts","sourceRoot":"","sources":["../../src/http/Http.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,CAAC,MAAM,kBAAkB,CAAC;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAOrE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAEhD,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAAC,CAAC;AAE5E,MAAM,MAAM,0BAA0B,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAC7B,0BAA0B,GAC1B,0BAA0B,EAAE,CAAC;AAEhC,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAEnE,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;AAE9C,MAAM,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,sBAAsB,GAAG,wBAAwB,CAAC;AAEhF,MAAM,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,WAAW,EAAE,eAAe,CAAC;IAC7B,IAAI,EAAE,eAAe,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;CACf,CAAC;AAEF,oBAAY,UAAU;IACrB,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,KAAK,UAAU;IACf,MAAM,WAAW;CACjB;AAED,oBAAY,eAAe;IAC1B,IAAI,qBAAqB;IACzB,WAAW,6BAA6B;IACxC,oBAAoB,wBAAwB;IAC5C,IAAI,eAAe;CACnB;AAED,oBAAY,UAAU;IACrB,aAAa,kBAAkB;IAC/B,WAAW,iBAAiB;IAC5B,aAAa,6BAA6B;IAC1C,SAAS,eAAe;IACxB,aAAa,mBAAmB;CAChC;AAED,MAAM,WAAW,oBAAoB;IACpC,GAAG,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IACvE,kBAAkB,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;CAC/D;AAED,eAAO,MAAM,WAAW,EAAE,oBAYzB,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,MAAM,CACxD,mBAAmB,EACnB,eAAe,CAGf,CAAC;AAEF,eAAO,MAAM,eAAe,SACrB,eAAe,qCAEkC,CAAC"}

package/dist/http/Http.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultiPartBody = exports.serializationFormatToHttpContentType = exports.HttpHeaders = exports.HttpHeader = exports.HttpContentType = exports.HttpMethod = void 0;
+const O = __importStar(require("fp-ts/lib/Option"));
+const function_1 = require("fp-ts/lib/function");
+const Serialization_1 = require("../serialization/Serialization");
+const getHeader = (headers, name) => O.fromNullable(headers[name.toLowerCase()]);
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["Get"] = "GET";
+    HttpMethod["Put"] = "PUT";
+    HttpMethod["Post"] = "POST";
+    HttpMethod["Patch"] = "PATCH";
+    HttpMethod["Delete"] = "DELETE";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var HttpContentType;
+(function (HttpContentType) {
+    HttpContentType["Json"] = "application/json";
+    HttpContentType["OctetStream"] = "application/octet-stream";
+    HttpContentType["MultipartRequestBody"] = "multipart/form-data";
+    HttpContentType["Text"] = "text/plain";
+})(HttpContentType || (exports.HttpContentType = HttpContentType = {}));
+var HttpHeader;
+(function (HttpHeader) {
+    HttpHeader["Authorization"] = "Authorization";
+    HttpHeader["ContentType"] = "Content-Type";
+    HttpHeader["Impersonation"] = "X-Tray-Admin-Impersonate";
+    HttpHeader["UserAgent"] = "User-Agent";
+    HttpHeader["ContentLength"] = "Content-Length";
+})(HttpHeader || (exports.HttpHeader = HttpHeader = {}));
+exports.HttpHeaders = {
+    get: (headers, name) => getHeader(headers, name),
+    extractBearerToken: (headers) => (0, function_1.pipe)(getHeader(headers, HttpHeader.Authorization), O.chain((header) => header.toLowerCase().startsWith('bearer ')
+        ? O.fromNullable(header.substring(7))
+        : O.fromNullable(null))),
+};
+exports.serializationFormatToHttpContentType = {
+    [Serialization_1.SerializationFormat.Json]: HttpContentType.Json,
+};
+const isMultiPartBody = (body) => (body === null || body === void 0 ? void 0 : body.files) !== undefined;
+exports.isMultiPartBody = isMultiPartBody;

package/dist/http/HttpClient.abstract.test.d.ts

@@ -0,0 +1,3 @@
+import { HttpClient } from './HttpClient';
+export declare function httpClientTest(httpClient: HttpClient): void;
+//# sourceMappingURL=HttpClient.abstract.test.d.ts.map

package/dist/http/HttpClient.abstract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.abstract.test.d.ts","sourceRoot":"","sources":["../../src/http/HttpClient.abstract.test.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,QAogBpD"}

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

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpClientTest = void 0;
+const E = __importStar(require("fp-ts/Either"));
+const stream_1 = require("stream");
+const function_1 = require("fp-ts/function");
+const t = __importStar(require("io-ts"));
+const http_1 = require("http");
+const util_1 = require("util");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const formidable_1 = __importDefault(require("formidable"));
+const Task_1 = require("../task/Task");
+const JsonSerialization_1 = require("../serialization/JsonSerialization");
+const TypeCodec_1 = require("../codec/TypeCodec");
+const Http_1 = require("./Http");
+const File_1 = require("../file/File");
+const NodeFsFileStorage_1 = require("../file/NodeFsFileStorage");
+const BufferExtensions_1 = require("../buffer/BufferExtensions");
+function httpClientTest(httpClient) {
+    const serialization = new JsonSerialization_1.JsonSerialization();
+    const fileStorage = new NodeFsFileStorage_1.NodeFsFileStorage();
+    const testErrorResponseCodec = TypeCodec_1.TypeCodec.fromDescriptor(t.type({
+        message: t.string,
+    }));
+    const testResponseCodec = TypeCodec_1.TypeCodec.fromDescriptor(t.type({
+        strField: t.string,
+        intField: t.number,
+    }));
+    const ReadableCodec = new t.Type('Readable', (input) => input instanceof stream_1.Readable, (input, ctx) => input instanceof stream_1.Readable ? t.success(input) : t.failure(input, ctx), (input) => input);
+    const testMultiPartBodyTypeCodec = TypeCodec_1.TypeCodec.fromDescriptor(t.type({
+        fields: t.record(t.string, t.string),
+        files: t.record(t.string, t.type({
+            key: t.string,
+            metadata: File_1.fileMetadataDescriptor,
+            content: t.any,
+        })),
+    }));
+    const testInputCodec = TypeCodec_1.TypeCodec.fromDescriptor(t.type({
+        inputField: t.number,
+    }));
+    function sendHttpResponse(httpResponse, response, responseCodec) {
+        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));
+            }
+            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) => {
+        const flattenedFields = {};
+        Object.entries(fields).forEach(([key, value]) => {
+            if (Array.isArray(value) && value.length > 1) {
+                throw new Error(`Field ${key} has more than one value and is current not supported`);
+            }
+            if (Array.isArray(value)) {
+                flattenedFields[key] = value.join(',');
+            }
+            else {
+                flattenedFields[key] = value !== null && value !== void 0 ? value : '';
+            }
+        });
+        return flattenedFields;
+    };
+    const flattenFiles = (files) => {
+        const flattenedFiles = {};
+        Object.entries(files)
+            .filter(([_key, file]) => file !== null)
+            .forEach(([key, file]) => {
+            if (Array.isArray(file) && file.length > 1) {
+                throw new Error(`Field ${key} has more than one file and is currently not supported`);
+            }
+            if (Array.isArray(file)) {
+                const fileContent = convertFormidableFileToTrayFile(file[0]);
+                flattenedFiles[key] = fileContent;
+            }
+        });
+        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;
+        if (req.method === 'GET' && typeof req.headers['error'] === 'string') {
+            const errorCode = +req.headers['error'];
+            res.writeHead(errorCode, {
+                [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json,
+            });
+            const errorResponse = {
+                message: `some error message ${errorCode}`,
+            };
+            sendHttpResponse(res, errorResponse, testErrorResponseCodec);
+        }
+        else if (req.method === 'GET') {
+            const customHeader = req.headers['x-custom-header'];
+            res.writeHead(200, { [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json });
+            const response = {
+                strField: customHeader,
+                intField: 123,
+            };
+            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))) {
+            res.writeHead(200, { [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json });
+            yield 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) => ({
+                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) => {
+                server.listen(port, host, resolve);
+            });
+        }));
+        afterAll(() => __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }));
+        test('should send a GET request', () => __awaiter(this, void 0, void 0, function* () {
+            const response = yield httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
+                headers: { 'x-custom-header': 'customVal' },
+                pathParams: {},
+                queryString: {},
+                body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(new ArrayBuffer(0)),
+            })();
+            const testValue = {
+                strField: 'customVal',
+                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();
+            expect(resultE).toStrictEqual(E.right(testValue));
+        }));
+        test('should send a POST request', () => __awaiter(this, void 0, void 0, function* () {
+            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, {
+                headers: {
+                    'x-custom-header': 'customVal',
+                },
+                pathParams: {},
+                queryString: {},
+                body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(serializedInput),
+            })))();
+            const testValue = {
+                strField: 'customVal',
+                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();
+            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({
+                key: 'file1',
+                metadata: {
+                    name: 'file1',
+                },
+                content: stream_1.Readable.from('file 1 content'),
+            })();
+            const file2 = yield fileStorage.write({
+                key: 'file2',
+                metadata: {
+                    name: 'file2',
+                },
+                content: stream_1.Readable.from('file 2 content'),
+            })();
+            if (file1._tag === 'Left') {
+                throw file1.left;
+            }
+            if (file2._tag === 'Left') {
+                throw file2.left;
+            }
+            const testInput = {
+                fields: {
+                    field1: 'field1',
+                    field2: 'field2',
+                },
+                files: {
+                    file1: {
+                        key: 'file1',
+                        metadata: {
+                            name: 'file1',
+                        },
+                        content: stream_1.Readable.from('Hello world'),
+                    },
+                    file2: {
+                        key: 'file2',
+                        metadata: {
+                            name: 'file2',
+                        },
+                        content: stream_1.Readable.from('Hello world'),
+                    },
+                },
+            };
+            const response = yield httpClient.execute(Http_1.HttpMethod.Post, baseUrl, {
+                headers: {
+                    'x-custom-header': 'customVal',
+                    'content-type': Http_1.HttpContentType.MultipartRequestBody,
+                },
+                pathParams: {},
+                queryString: {},
+                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();
+            expect(resultE).toEqual(E.right(expect.objectContaining({
+                fields: testInput.fields,
+                files: expect.objectContaining({
+                    file1: expect.objectContaining({
+                        key: expect.any(String),
+                        metadata: expect.objectContaining({
+                            name: 'file1',
+                        }),
+                    }),
+                    file2: expect.objectContaining({
+                        key: expect.any(String),
+                        metadata: expect.objectContaining({
+                            name: 'file2',
+                        }),
+                    }),
+                }),
+            })));
+        }));
+        test('should parse an internal error response', () => __awaiter(this, void 0, void 0, function* () {
+            const response = yield httpClient.execute(Http_1.HttpMethod.Get, baseUrl, {
+                headers: { error: '500' },
+                pathParams: {},
+                queryString: {},
+                body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(new ArrayBuffer(0)),
+            })();
+            const testErrorResponse = {
+                message: 'some error message 500',
+            };
+            if (E.isLeft(response)) {
+                throw response.left;
+            }
+            const responseBodyE = yield 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, {
+                headers: { error: '404' },
+                pathParams: {},
+                queryString: {},
+                body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(new ArrayBuffer(0)),
+            })();
+            const testErrorResponse = {
+                message: 'some error message 404',
+            };
+            if (E.isLeft(response)) {
+                throw response.left;
+            }
+            const responseBodyE = yield 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/http/HttpClient.d.ts

@@ -0,0 +1,6 @@
+import { TaskEither } from 'fp-ts/TaskEither';
+import { HttpMethod, HttpRequest, HttpResponse } from './Http';
+export interface HttpClient {
+    execute(method: HttpMethod, url: string, request: HttpRequest): TaskEither<Error, HttpResponse>;
+}
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/http/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../../src/http/HttpClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAE/D,MAAM,WAAW,UAAU;IAC1B,OAAO,CACN,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,WAAW,GAClB,UAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;CACnC"}

package/dist/http/HttpClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/http/HttpController.d.ts

@@ -0,0 +1,11 @@
+import * as T from 'fp-ts/Task';
+import { HttpMethod, HttpRequest, HttpResponse } from './Http';
+export interface HttpController {
+    getEndpoints: () => ReadonlyArray<HttpEndpoint>;
+}
+export interface HttpEndpoint {
+    path: string;
+    method: HttpMethod;
+    execute: (request: HttpRequest) => T.Task<HttpResponse>;
+}
+//# sourceMappingURL=HttpController.d.ts.map

package/dist/http/HttpController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpController.d.ts","sourceRoot":"","sources":["../../src/http/HttpController.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,YAAY,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC9B,YAAY,EAAE,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;CACxD"}

package/dist/http/HttpController.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logging/Logging.d.ts

@@ -0,0 +1,10 @@
+export interface Logging {
+    info(message: string, octx: ObservabilityContext): void;
+    debug(message: string, octx: ObservabilityContext): void;
+    error(message: string, octx: ObservabilityContext): void;
+    warning(message: string, octx: ObservabilityContext): void;
+}
+export interface ObservabilityContext {
+    [key: string]: string | number | Record<string, string>;
+}
+//# sourceMappingURL=Logging.d.ts.map

package/dist/logging/Logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logging.d.ts","sourceRoot":"","sources":["../../src/logging/Logging.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACvB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAExD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAEzD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAEzD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,oBAAoB;IACpC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxD"}

package/dist/logging/Logging.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/record/Record.d.ts

@@ -0,0 +1,4 @@
+import * as O from 'fp-ts/Option';
+export declare const addValueToRecordIfPresent: <K extends string | number | symbol, V>(record: Record<K, V>, key: K, valueOpt: O.Option<V>) => Record<K, V>;
+export declare const addValuesToRecordIfPresent: <K extends string | number | symbol, V>(record: Record<K, V>, valuesToAdd: Record<K, O.Option<V>>) => Record<K, V>;
+//# sourceMappingURL=Record.d.ts.map

package/dist/record/Record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../../src/record/Record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,yBAAyB,8GAUpC,CAAC;AAEH,eAAO,MAAM,0BAA0B,oHAMC,CAAC"}