@j2blasco/ts-result 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/result.d.ts

@@ -0,0 +1,34 @@
+export interface Result<TSuccess1, TError1> {
+    andThen<TResult extends Result<any, any>>(f: (value: TSuccess1) => TResult): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;
+    andThenAsync<TResult extends Result<any, any>>(f: (value: TSuccess1) => Promise<TResult>): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;
+    catchError<TResult extends Result<any, any>>(f: (error: TError1) => TResult): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;
+    catchErrorAsync<TResult extends Result<any, any>>(f: (error: TError1) => Promise<TResult>): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;
+    unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;
+}
+export declare function unwrapSuccessResult<T>(result: Result<T, never>): T;
+export type ErrorWithCode<TCode, TData = object> = {
+    code: TCode;
+    data: TData;
+};
+export declare function errorWithCode<TCode, TData>(code: TCode, data: TData): ErrorWithCode<TCode, TData>;
+export type ErrorUnknown = {
+    code: 'unknown';
+    data: {
+        message: string;
+    };
+};
+export declare function errorUnkown(message: string): ErrorUnknown;
+export type SuccessType<T> = T extends Result<infer S, any> ? S : never;
+export type ErrorType<T> = T extends Result<any, infer E> ? E : never;
+export type SuccessVoid = never;
+export declare function resultSuccessVoid(): Result<SuccessVoid, never>;
+export declare function resultSuccess<TSuccess1>(value: TSuccess1): Result<TSuccess1, never>;
+type EnforceLiteral<T> = string extends T ? never : T;
+export declare class resultError {
+    static unknown(message: string): Result<never, ErrorUnknown>;
+    static withCode<TCode, TData = object>(code: EnforceLiteral<TCode>, data?: TData): Result<never, ErrorWithCode<TCode, TData>>;
+    static fromError<TSuccess1, TError1 extends ErrorWithCode<any, object>>(error: TError1): Result<TSuccess1, TError1>;
+}
+export type UnwrapErrorFromResult<T> = T extends Result<any, infer U> ? U : never;
+export declare function makeSafePromise<T>(promise: Promise<T>): Promise<Result<T, ErrorUnknown>>;
+export {};

package/dist/result.js

@@ -0,0 +1,100 @@
+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());
+    });
+};
+export function unwrapSuccessResult(result) {
+    if (result instanceof ResultSuccessImp) {
+        return result['value'];
+    }
+    throw new Error('Unreachable code. Result is an error');
+}
+export function errorWithCode(code, data) {
+    return {
+        code,
+        data,
+    };
+}
+export function errorUnkown(message) {
+    return {
+        code: 'unknown',
+        data: { message },
+    };
+}
+export function resultSuccessVoid() {
+    return new ResultSuccessImp(undefined);
+}
+export function resultSuccess(value) {
+    return new ResultSuccessImp(value);
+}
+export class resultError {
+    static unknown(message) {
+        return new ResultErrorImp(errorUnkown(message));
+    }
+    static withCode(code, data = {}) {
+        return new ResultErrorImp(errorWithCode(code, data));
+    }
+    static fromError(error) {
+        return new ResultErrorImp(error);
+    }
+}
+class ResultSuccessImp {
+    constructor(value) {
+        this.value = value;
+    }
+    andThen(f) {
+        return f(this.value);
+    }
+    andThenAsync(f) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield f(this.value);
+        });
+    }
+    catchError(_f) {
+        return this;
+    }
+    catchErrorAsync(_f) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this;
+        });
+    }
+    unwrapOrThrow(_errorCallback) {
+        return this.value;
+    }
+}
+class ResultErrorImp {
+    constructor(error) {
+        this.error = error;
+    }
+    andThen(_f) {
+        return this;
+    }
+    andThenAsync(_f) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this;
+        });
+    }
+    catchError(f) {
+        return f(this.error);
+    }
+    catchErrorAsync(f) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield f(this.error);
+        });
+    }
+    unwrapOrThrow(errorCallback) {
+        if (errorCallback !== undefined) {
+            errorCallback(this.error);
+        }
+        throw this.error;
+    }
+}
+export function makeSafePromise(promise) {
+    return promise
+        .then((value) => resultSuccess(value))
+        .catch((error) => resultError.unknown(error.message));
+}

package/dist/result.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/result.test.js

@@ -0,0 +1,55 @@
+import { resultSuccess, resultError, unwrapSuccessResult, resultSuccessVoid, } from "./result";
+import { assertType, expectToCompile } from "./utils/test/assert-type";
+function createResult() {
+    return resultSuccessVoid();
+}
+describe("Result Monad", () => {
+    test("resultSuccess should create a success result", () => {
+        const success = resultSuccess("test");
+        expect(unwrapSuccessResult(success)).toBe("test");
+    });
+    test("resultError.unknown should create an unknown error result", () => {
+        const error = resultError.unknown("An error occurred");
+        try {
+            error.unwrapOrThrow();
+        }
+        catch (e) {
+            expect(e).toMatchObject({
+                code: "unknown",
+                data: { message: "An error occurred" },
+            });
+        }
+    });
+    test("resultError.withCode should create a coded error result", () => {
+        const error = resultError.withCode("test-code", {
+            detail: "Some details",
+        });
+        try {
+            error.unwrapOrThrow();
+        }
+        catch (e) {
+            expect(e).toMatchObject({
+                code: "test-code",
+                data: { detail: "Some details" },
+            });
+        }
+    });
+    test("Result Monad success should be chainable with inferred types - string -> int", () => {
+        const resultString = createResult();
+        const resultInt = resultString.andThen((value) => {
+            assertType(true);
+            return resultSuccess(42);
+        });
+        assertType(true);
+        expectToCompile();
+    });
+    test("Result Monad success should be chainable with inferred types - obj -> obj", () => {
+        const resultString = createResult();
+        const resultInt = resultString.andThen((value) => {
+            assertType(true);
+            return resultSuccess({ test2: "test" });
+        });
+        assertType(true);
+        expectToCompile();
+    });
+});

package/dist/utils/test/assert-type.d.ts

@@ -0,0 +1,2 @@
+export declare function assertType<TActual, TExpected>(_value: TActual extends TExpected ? true : false): void;
+export declare function expectToCompile(): void;

package/dist/utils/test/assert-type.js

@@ -0,0 +1,4 @@
+export function assertType(_value) { }
+export function expectToCompile() {
+    expect(true).toBe(true);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@j2blasco/ts-result",
+  "version": "0.0.1",
+  "description": "Result Monad for TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "test": "jest",
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.2"
+  }
+}