@trayio/commons 0.11.0

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

@@ -0,0 +1,191 @@
+"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.httpClientTest = void 0;
+const E = __importStar(require("fp-ts/Either"));
+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 Task_1 = require("../task/Task");
+const JsonSerialization_1 = require("../serialization/JsonSerialization");
+const TypeCodec_1 = require("../codec/TypeCodec");
+const Http_1 = require("./Http");
+function httpClientTest(httpClient) {
+    const serialization = new JsonSerialization_1.JsonSerialization();
+    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 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) {
+        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 requestListener = (req, res) => {
+        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 {
+            const customHeader = req.headers['x-custom-header'];
+            res.writeHead(200, { [Http_1.HttpHeader.ContentType]: Http_1.HttpContentType.Json });
+            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: new ArrayBuffer(0),
+            })();
+            const testValue = {
+                strField: 'customVal',
+                intField: 123,
+            };
+            const result = (0, function_1.pipe)(response, E.chain((httpResponse) => serialization.deserialize(httpResponse.body)), E.chain((encoded) => testResponseCodec.decode(encoded)));
+            expect(result).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: serializedInput,
+            })))();
+            const testValue = {
+                strField: 'customVal',
+                intField: 321,
+            };
+            const result = (0, function_1.pipe)(response, E.chain((httpResponse) => serialization.deserialize(httpResponse.body)), E.chain((encoded) => testResponseCodec.decode(encoded)));
+            expect(result).toStrictEqual(E.right(testValue));
+        }));
+        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: new ArrayBuffer(0),
+            })();
+            const testErrorResponse = {
+                message: 'some error message 500',
+            };
+            const expectedResponse = (0, function_1.pipe)(response, E.bindTo('httpResponse'), E.bind('serialisedErrorResponse', () => E.right(serialization.serialize(testErrorResponseCodec.encode(testErrorResponse)))), E.map(({ httpResponse, serialisedErrorResponse }) => ({
+                headers: httpResponse.headers,
+                statusCode: 500,
+                body: Buffer.from(serialisedErrorResponse),
+            })));
+            expect(response).toStrictEqual(expectedResponse);
+        }));
+        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: new ArrayBuffer(0),
+            })();
+            const testErrorResponse = {
+                message: 'some error message 404',
+            };
+            const expectedResponse = (0, function_1.pipe)(response, E.bindTo('httpResponse'), E.bind('serialisedErrorResponse', () => E.right(serialization.serialize(testErrorResponseCodec.encode(testErrorResponse)))), E.map(({ httpResponse, serialisedErrorResponse }) => ({
+                headers: httpResponse.headers,
+                statusCode: 404,
+                body: Buffer.from(serialisedErrorResponse),
+            })));
+            expect(response).toStrictEqual(expectedResponse);
+        }));
+    });
+}
+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"}

package/dist/record/Record.js

@@ -0,0 +1,35 @@
+"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.addValuesToRecordIfPresent = exports.addValueToRecordIfPresent = void 0;
+const O = __importStar(require("fp-ts/Option"));
+const A = __importStar(require("fp-ts/Array"));
+const addValueToRecordIfPresent = (record, key, valueOpt) => O.getOrElse(() => record)(O.map((value) => {
+    record[key] = value;
+    return record;
+})(valueOpt));
+exports.addValueToRecordIfPresent = addValueToRecordIfPresent;
+const addValuesToRecordIfPresent = (record, valuesToAdd) => A.reduce(record, (acc, key) => (0, exports.addValueToRecordIfPresent)(acc, key, valuesToAdd[key]))(Object.keys(valuesToAdd));
+exports.addValuesToRecordIfPresent = addValuesToRecordIfPresent;

package/dist/result/Result.d.ts

@@ -0,0 +1,31 @@
+import * as E from 'fp-ts/Either';
+export type Failure<E> = {
+    readonly _tag: 'Failure';
+    readonly isSuccess: false;
+    readonly isFailure: true;
+    readonly error: E;
+};
+export type Success<T> = {
+    readonly _tag: 'Success';
+    readonly isSuccess: true;
+    readonly isFailure: false;
+    readonly value: T;
+};
+export type Result<E, T> = Failure<E> | Success<T>;
+export declare class ResultFailureError<E> extends Error {
+    failureCause: E;
+    constructor(failureCause: E);
+}
+export interface ResultInterface {
+    success: <E, T>(value: T) => Result<E, T>;
+    failure: <E, T>(error: E) => Result<E, T>;
+    getSuccessfulValueOrFail: <E, T>(result: Result<E, T>) => T;
+    map: <E, T, R>(result: Result<E, T>, mapping: (value: T) => R) => Result<E, R>;
+}
+export declare const Result: ResultInterface;
+export interface ResultInternalInterface {
+    fromEitherWithSimpleError: <T>(either: E.Either<Error, T>) => Result<Error, T>;
+    fromEitherWithSimpleErrorAndUnknown: <T>(either: E.Either<Error, unknown>) => Result<Error, T>;
+}
+export declare const ResultInternal: ResultInternalInterface;
+//# sourceMappingURL=Result.d.ts.map

package/dist/result/Result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Result.d.ts","sourceRoot":"","sources":["../../src/result/Result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEnD,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,KAAK;IAC5B,YAAY,EAAE,CAAC;gBAAf,YAAY,EAAE,CAAC;CAOlC;AAED,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1C,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1C,wBAAwB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;IAC5D,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACZ,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB;AAED,eAAO,MAAM,MAAM,EAAE,eAgCpB,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACvC,yBAAyB,EAAE,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,KACtB,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACtB,mCAAmC,EAAE,CAAC,CAAC,EACtC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,KAC5B,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;CACtB;AAED,eAAO,MAAM,cAAc,EAAE,uBAgB5B,CAAC"}

package/dist/result/Result.js

@@ -0,0 +1,68 @@
+"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.ResultInternal = exports.Result = exports.ResultFailureError = void 0;
+const E = __importStar(require("fp-ts/Either"));
+class ResultFailureError extends Error {
+    constructor(failureCause) {
+        super(`Result could not be read because it is a failure: ${JSON.stringify(failureCause)}`);
+        this.failureCause = failureCause;
+    }
+}
+exports.ResultFailureError = ResultFailureError;
+exports.Result = {
+    success: (value) => ({
+        _tag: 'Success',
+        isSuccess: true,
+        isFailure: false,
+        value,
+    }),
+    failure: (error) => ({
+        _tag: 'Failure',
+        isSuccess: false,
+        isFailure: true,
+        error,
+    }),
+    getSuccessfulValueOrFail(result) {
+        switch (result.isSuccess) {
+            case true:
+                return result.value;
+            case false:
+                throw new ResultFailureError(result.error);
+        }
+    },
+    map: (result, mapping) => {
+        switch (result.isSuccess) {
+            case true:
+                return exports.Result.success(mapping(result.value));
+            case false:
+                return exports.Result.failure(result.error);
+        }
+    },
+};
+exports.ResultInternal = {
+    fromEitherWithSimpleError: (either) => E.match((error) => exports.Result.failure(error), (value) => exports.Result.success(value))(either),
+    fromEitherWithSimpleErrorAndUnknown: (either) => E.match((error) => exports.Result.failure(error), (value) => exports.Result.success(value))(either),
+};

package/dist/serialization/JsonSerialization.d.ts

@@ -0,0 +1,10 @@
+import * as E from 'fp-ts/Either';
+import { Serialization, SerializationFormat } from './Serialization';
+export declare class JsonSerialization implements Serialization {
+    private textEncoder;
+    private textDecoder;
+    format: SerializationFormat;
+    serialize(value: unknown): ArrayBuffer;
+    deserialize(value: ArrayBuffer): E.Either<Error, unknown>;
+}
+//# sourceMappingURL=JsonSerialization.d.ts.map

package/dist/serialization/JsonSerialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSerialization.d.ts","sourceRoot":"","sources":["../../src/serialization/JsonSerialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAGrE,qBAAa,iBAAkB,YAAW,aAAa;IACtD,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,WAAW,CAAqB;IAExC,MAAM,EAAE,mBAAmB,CAA4B;IAEvD,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW;IAKtC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC;CASzD"}

package/dist/serialization/JsonSerialization.js

@@ -0,0 +1,49 @@
+"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.JsonSerialization = void 0;
+const E = __importStar(require("fp-ts/Either"));
+const util_1 = require("util");
+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;
+    }
+    serialize(value) {
+        const json = JSON.stringify(value);
+        return this.textEncoder.encode(json).buffer;
+    }
+    deserialize(value) {
+        if (value.byteLength === 0) {
+            return E.right(undefined);
+        }
+        return (0, function_1.pipe)((0, Try_1.tryToEither)(() => this.textDecoder.decode(value)), E.chain((str) => (0, Try_1.tryToEither)(() => JSON.parse(str))));
+    }
+}
+exports.JsonSerialization = JsonSerialization;

package/dist/serialization/JsonSerialization.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=JsonSerialization.unit.test.d.ts.map

package/dist/serialization/JsonSerialization.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSerialization.unit.test.d.ts","sourceRoot":"","sources":["../../src/serialization/JsonSerialization.unit.test.ts"],"names":[],"mappings":""}

package/dist/serialization/JsonSerialization.unit.test.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Serialization_abstract_test_1 = require("./Serialization.abstract.test");
+const JsonSerialization_1 = require("./JsonSerialization");
+(0, Serialization_abstract_test_1.testSerialization)(new JsonSerialization_1.JsonSerialization());

package/dist/serialization/Serialization.abstract.test.d.ts

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

package/dist/serialization/Serialization.abstract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serialization.abstract.test.d.ts","sourceRoot":"","sources":["../../src/serialization/Serialization.abstract.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,aAAa,QAyC7D"}

package/dist/serialization/Serialization.abstract.test.js

@@ -0,0 +1,54 @@
+"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.testSerialization = void 0;
+const E = __importStar(require("fp-ts/Either"));
+const O = __importStar(require("fp-ts/Option"));
+const function_1 = require("fp-ts/function");
+function testSerialization(serialization) {
+    describe('Serialization Test', () => {
+        test('should serialize and deserialize a value', () => {
+            const testValue = {
+                strField: 'str',
+                intField: O.some(123),
+            };
+            const result = (0, function_1.pipe)(E.right(serialization.serialize(testValue)), E.chain((serialized) => serialization.deserialize(serialized)));
+            expect(result).toStrictEqual(E.right(testValue));
+        });
+        test('should serialize undefined', () => {
+            const undefinedType = undefined;
+            const result = serialization.serialize(undefinedType);
+            const expected = new ArrayBuffer(0);
+            expect(result).toStrictEqual(expected);
+        });
+        test('should deserialize undefined', () => {
+            const undefinedSerialised = new ArrayBuffer(0);
+            const result = serialization.deserialize(undefinedSerialised);
+            const expected = E.right(undefined);
+            expect(result).toStrictEqual(expected);
+        });
+    });
+}
+exports.testSerialization = testSerialization;

package/dist/serialization/Serialization.d.ts

@@ -0,0 +1,10 @@
+import * as E from 'fp-ts/Either';
+export declare enum SerializationFormat {
+    Json = "Json"
+}
+export interface Serialization {
+    format: SerializationFormat;
+    serialize(value: unknown): ArrayBuffer;
+    deserialize(value: ArrayBuffer): E.Either<Error, unknown>;
+}
+//# sourceMappingURL=Serialization.d.ts.map

package/dist/serialization/Serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serialization.d.ts","sourceRoot":"","sources":["../../src/serialization/Serialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,oBAAY,mBAAmB;IAC9B,IAAI,SAAS;CACb;AAED,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAE5B,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC;IAEvC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;CAC1D"}

package/dist/serialization/Serialization.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationFormat = void 0;
+var SerializationFormat;
+(function (SerializationFormat) {
+    SerializationFormat["Json"] = "Json";
+})(SerializationFormat || (exports.SerializationFormat = SerializationFormat = {}));

package/dist/string/StringExtensions.d.ts

@@ -0,0 +1,6 @@
+export interface StringExtensionsInterface {
+    pascalCase: (str: string) => string;
+    titleCase: (str: string) => string;
+}
+export declare const StringExtensions: StringExtensionsInterface;
+//# sourceMappingURL=StringExtensions.d.ts.map

package/dist/string/StringExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringExtensions.d.ts","sourceRoot":"","sources":["../../src/string/StringExtensions.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,yBAAyB;IACzC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CACnC;AAED,eAAO,MAAM,gBAAgB,EAAE,yBAI9B,CAAC"}

package/dist/string/StringExtensions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringExtensions = void 0;
+const lodash_1 = require("lodash");
+exports.StringExtensions = {
+    pascalCase: (str) => (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(str)),
+    titleCase: (value) => (0, lodash_1.capitalize)((0, lodash_1.startCase)(value).replace(/_|-/g, ' ')),
+};

package/dist/string/StringExtensions.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StringExtensions.unit.test.d.ts.map

package/dist/string/StringExtensions.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringExtensions.unit.test.d.ts","sourceRoot":"","sources":["../../src/string/StringExtensions.unit.test.ts"],"names":[],"mappings":""}

package/dist/string/StringExtensions.unit.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StringExtensions_1 = require("./StringExtensions");
+describe('StringExtensions', () => {
+    describe('pascalCase', () => {
+        it('should convert lowercase string to pascal case', () => {
+            expect(StringExtensions_1.StringExtensions.pascalCase('helloWorld')).toBe('HelloWorld');
+        });
+        it('should convert snake_case string to pascal case', () => {
+            expect(StringExtensions_1.StringExtensions.pascalCase('snake_case_example')).toBe('SnakeCaseExample');
+        });
+        it('should convert kebab-case string to pascal case', () => {
+            expect(StringExtensions_1.StringExtensions.pascalCase('kebab-case-example')).toBe('KebabCaseExample');
+        });
+        it('should handle empty string', () => {
+            expect(StringExtensions_1.StringExtensions.pascalCase('')).toBe('');
+        });
+        it('should handle single-letter string', () => {
+            expect(StringExtensions_1.StringExtensions.pascalCase('a')).toBe('A');
+        });
+    });
+    describe('titleCase', () => {
+        it('should convert lowercase string to title case', () => {
+            expect(StringExtensions_1.StringExtensions.titleCase('hello world')).toBe('Hello world');
+        });
+        it('should convert snake_case string to title case', () => {
+            expect(StringExtensions_1.StringExtensions.titleCase('snake_case_example')).toBe('Snake case example');
+        });
+        it('should convert kebab-case string to title case', () => {
+            expect(StringExtensions_1.StringExtensions.titleCase('kebab-case-example')).toBe('Kebab case example');
+        });
+        it('should handle empty string', () => {
+            expect(StringExtensions_1.StringExtensions.titleCase('')).toBe('');
+        });
+        it('should handle single-letter string', () => {
+            expect(StringExtensions_1.StringExtensions.titleCase('a')).toBe('A');
+        });
+    });
+});