@openally/result - npm Package Compare versions

Comparing version 1.2.1 to 1.3.0

dist/index.d.ts

@@ -7,7 +7,10 @@ declare class ErrImpl<E> {
     constructor(val: E);
+    unwrap(): never;
     unwrapOr<T2>(val: T2): T2;
-    unwrap(): never;
+    unwrapOrElse<T2>(mapper: (val: E) => T2): T2;
     map(_mapper: unknown): ErrImpl<E>;
+    mapOr<U>(default_: U, _mapper: unknown): U;
+    mapOrElse<U>(default_: (error: E) => U, _mapper: unknown): U;
+    mapErr<E2>(mapper: (err: E) => E2): ErrImpl<E2>;
     andThen(op: unknown): ErrImpl<E>;
-    mapErr<E2>(mapper: (err: E) => E2): ErrImpl<E2>;
     get stack(): string;
@@ -22,10 +25,13 @@ }
     constructor(val: T);
+    unwrap(): T;
     unwrapOr(_val: unknown): T;
-    unwrap(): T;
+    unwrapOrElse(_mapper: unknown): T;
     safeUnwrap(): T;
     map<T2>(mapper: (val: T) => T2): OkImpl<T2>;
+    mapOr<U>(_default_: U, mapper: (val: T) => U): U;
+    mapOrElse<U>(_default_: (error: unknown) => U, mapper: (val: T) => U): U;
+    mapErr(_mapper: unknown): OkImpl<T>;
     andThen<T2>(mapper: (val: T) => OkImpl<T2>): OkImpl<T2>;
     andThen<E2>(mapper: (val: T) => ErrImpl<E2>): Result<T, E2>;
     andThen<T2, E2>(mapper: (val: T) => Result<T2, E2>): Result<T2, E2>;
-    mapErr(_mapper: unknown): OkImpl<T>;
 }
@@ -37,5 +43,8 @@ declare function Ok<T>(value: T): OkImpl<T>;
     readonly none = true;
+    unwrap(): never;
     unwrapOr<T2>(val: T2): T2;
-    unwrap(): never;
+    unwrapOrElse<T2>(f: () => T2): T2;
     map(_mapper: unknown): None;
+    mapOr<T2>(default_: T2, _mapper: unknown): T2;
+    mapOrElse<U>(default_: () => U, _mapper: unknown): U;
     andThen(op: unknown): None;
@@ -55,9 +64,12 @@ toResult<E>(error: E): ErrImpl<E>;
     constructor(val: T);
-    unwrapOr(_val: unknown): T;
     expect(_msg: string): T;
     unwrap(): T;
+    unwrapOr(_val: unknown): T;
+    unwrapOrElse(_mapper: unknown): T;
+    safeUnwrap(): T;
     map<T2>(mapper: (val: T) => T2): SomeImpl<T2>;
+    mapOr<T2>(_default_: T2, mapper: (val: T) => T2): T2;
+    mapOrElse<U>(default_: () => U, _mapper: (val: T) => U): U;
     andThen<T2>(mapper: (val: T) => Option<T2>): Option<T2>;
     toResult<E>(error: E): OkImpl<T>;
-    safeUnwrap(): T;
     toString(): string;
@@ -64,0 +76,0 @@ }

dist/index.js

@@ -40,6 +40,9 @@ var __defProp = Object.defineProperty;
   }
+  unwrap() {
+    return this.val;
+  }
   unwrapOr(_val) {
     return this.val;
   }
-  unwrap() {
+  unwrapOrElse(_mapper) {
     return this.val;
@@ -53,8 +56,14 @@ }
   }
-  andThen(mapper) {
+  mapOr(_default_, mapper) {
     return mapper(this.val);
   }
+  mapOrElse(_default_, mapper) {
+    return mapper(this.val);
+  }
   mapErr(_mapper) {
     return this;
   }
+  andThen(mapper) {
+    return mapper(this.val);
+  }
 };
@@ -93,5 +102,2 @@ function Ok(value) {
   }
-  unwrapOr(val) {
-    return val;
-  }
   unwrap() {
@@ -104,11 +110,23 @@ if (this.val instanceof Error) {
   }
+  unwrapOr(val) {
+    return val;
+  }
+  unwrapOrElse(mapper) {
+    return mapper(this.val);
+  }
   map(_mapper) {
     return this;
   }
-  andThen(op) {
-    return this;
+  mapOr(default_, _mapper) {
+    return default_;
   }
+  mapOrElse(default_, _mapper) {
+    return default_(this.val);
+  }
   mapErr(mapper) {
     return new _ErrImpl(mapper(this.val));
   }
+  andThen(op) {
+    return this;
+  }
   get stack() {
@@ -134,9 +152,15 @@ return `${this}
   }
+  expect(_msg) {
+    return this.val;
+  }
+  unwrap() {
+    return this.val;
+  }
   unwrapOr(_val) {
     return this.val;
   }
-  expect(_msg) {
+  unwrapOrElse(_mapper) {
     return this.val;
   }
-  unwrap() {
+  safeUnwrap() {
     return this.val;
@@ -147,12 +171,14 @@ }
   }
+  mapOr(_default_, mapper) {
+    return mapper(this.val);
+  }
+  mapOrElse(default_, _mapper) {
+    return default_();
+  }
   andThen(mapper) {
     return mapper(this.val);
   }
-  // eslint-disable-next-line handle-callback-err
   toResult(error) {
     return Ok(this.val);
   }
-  safeUnwrap() {
-    return this.val;
-  }
   toString() {
@@ -170,7 +196,10 @@ return `Some(${toString(this.val)})`;
   none = true;
+  unwrap() {
+    throw new Error("Tried to unwrap None");
+  }
   unwrapOr(val) {
     return val;
   }
-  unwrap() {
-    throw new Error("Tried to unwrap None");
+  unwrapOrElse(f) {
+    return f();
   }
@@ -180,2 +209,8 @@ map(_mapper) {
   }
+  mapOr(default_, _mapper) {
+    return default_;
+  }
+  mapOrElse(default_, _mapper) {
+    return default_();
+  }
   andThen(op) {
@@ -182,0 +217,0 @@ return this;

package.json

 {
   "name": "@openally/result",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Another inspired Rust's Result implementation.",
@@ -5,0 +5,0 @@ "main": "./dist/index.js",

README.md

@@ -6,3 +6,3 @@ <p align="center"><h1 align="center">
 <p align="center">
-  [WIP] Another Rust's Result implementation (inspired by <a href="https://github.com/vultix/ts-results">ts-results</a>)
+  Another Rust's Result implementation (inspired by <a href="https://github.com/vultix/ts-results">ts-results</a>)
 </p>
@@ -41,6 +41,43 @@
 
+Where Result could be either an Ok or Err
+
+```ts
+type Result<T, E> = OkImpl<T> | ErrImpl<E>;
+```
+
+---
+
+You can combine that package with [ts-pattern](https://github.com/gvergnaud/ts-pattern#readme), here is an example;
+
+```ts
+return match(constraint.type)
+  .with("PRIMARY KEY", () => (
+    column.isPrimary ? None : Some({ columnName, type: "MISSING PK" })
+  ))
+  .with("UNIQUE", () => helper
+    .getUniqueByColumnName(columnName)
+    .unwrapOr(Some({ columnName, type: "MISSING UNIQUE" }))
+  )
+  .with("FOREIGN KEY", () => helper
+    .getForeignKeyByColumnName(columnName)
+    .andThen((fk) => {
+      return helper.fkIsMatchingConstraint(fk, constraint) ?
+        Some({ columnName, type: "INVALID FK REFERENCE", constraint }) :
+        None;
+    })
+    .unwrapOr(Some({ columnName, type: "MISSING FK" }))
+  )
+  .otherwise(() => None) as Option<IConstraintDifference>;
+```
+
+Where Option is defined as being Some value or None.
+
+```ts
+type Option<T> = SomeImpl<T> | None
+```
+
 ## API
 
-### unwrap()
-Unwrap value (throw if error).
+### unwrap
+Get value if Ok but throw if Err.
 
@@ -52,4 +89,4 @@ ```ts
 
-### unwrapOr(value)
-Unwrap with a default value (if an error is detected).
+### unwrapOr
+Get value if Ok but fallback to a default value if Err (instead of throwing an Error).
 
@@ -61,6 +98,17 @@ ```ts
 
-### map()
-Map for an Ok value.
+### unwrapOrElse
+Same as `unwrapOr` but use a lazy function for the default value.
 
 ```ts
+Ok(1).unwrapOrElse(() => 5); // 1
+Err("oops").unwrapOrElse(() => 5); // 5
+```
+
+### safeUnwrap
+Same as `unwrap` but only available for Ok (useful for type safety).
+
+### map
+Map value for Ok. Do nothing with Err (use `mapErr` instead).
+
+```ts
 Ok(1)
@@ -71,8 +119,39 @@ .map((v) => v + 1)
 
-### mapErr()
-Map for an Error value.
+### mapOr
+Map and unwrap:
+- Use default value for Error
+- Use mapper for Ok
 
-### andThen()
+```ts
+Ok(1)
+  .mapOr(1, (val) => val * 2); // 2
 
+Err(new Error("oops"))
+  .mapOr(1, (val) => val * 2); // 1
+```
+
+### mapOrElse
+Same as `mapOr` but use a callback returning error for default value
+
 ```ts
+Err(new Error("oops"))
+  .mapOrElse(
+    (err) => err.message),
+    (val) => val * 2
+  ); // oops
+```
+
+### mapErr
+Map value for Err. Do nothing with Ok (use `map` instead).
+
+```ts
+Err(new Error("oops"))
+  .mapErr((cause) => new Error("oh no", { cause }))
+  .unwrap();
+```
+
+### andThen
+Similar to Promise.then, map and transform an Ok value.
+
+```ts
 Ok(1)
@@ -83,3 +162,13 @@ .andThen((value) => Ok(value + 1))
 
+This could be used to transform an Ok to an Err.
+
+### stack
+Return the Err stacktrace (not available for Ok).
+
+```ts
+const _e = Err(new Error());
+console.log(_e.stack);
+```
+
 ## License
 MIT

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

19407

increased by32.53%

Lines of code

549

increased by17.56%

Number of lines in readme file

169

increased by111.25%

No dependency changes