Async Handling

import { Result } from "@carbonteq/fp";

type User = { id: string; name: string };

async function fetchUser(id: string): Promise<Result<User, Error>> {
  return Result.tryAsyncCatch(
    async () => {
      const res = await fetch(`/api/users/${id}`);
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json() as Promise<User>;
    },
    (e) => (e instanceof Error ? e : new Error(String(e))),
  ).toPromise();
}

const user = await fetchUser("123");
console.log(user); // Result.Ok({ id, name }) or Result.Err(Error)

import { Result } from "@carbonteq/fp";

type Order = { id: string; total: number };
type Payment = { paymentId: string };

declare function loadOrder(id: string): Promise<Order>;
declare function processPayment(order: Order): Promise<Payment>;

async function checkout(orderId: string): Promise<Result<string, Error>> {
  return Result.tryAsyncCatch(() => loadOrder(orderId), (e) => e as Error)
    .flatMap((order: Order) =>
      Result.tryAsyncCatch(() => processPayment(order), (e) => e as Error),
    )
    .map((payment: Payment) => payment.paymentId)
    .toPromise();
}

import { Result } from "@carbonteq/fp";

type SignupInput = { email: string; password: string };

const validateFormat = (input: SignupInput) =>
  input.email.includes("@") ? Result.Ok(input) : Result.Err("Invalid email");

const validatePassword = (input: SignupInput) =>
  input.password.length >= 8 ? Result.Ok(input) : Result.Err("Password too short");

declare function checkDatabase(email: string): Promise<boolean>;

async function checkEmailAvailable(input: SignupInput): Promise<Result<SignupInput, string>> {
  const taken = await checkDatabase(input.email);
  return taken ? Result.Err("Email taken") : Result.Ok(input);
}

async function signup(input: SignupInput) {
  return Result.Ok(input)
    .validate([validateFormat, validatePassword, checkEmailAvailable])
    .toPromise();
}

import { Result } from "@carbonteq/fp";

type Order = { id: string; email: string };

declare function validateOrder(order: Order): Result<Order, Error>;
declare function chargePayment(order: Order): Promise<Result<Order, Error>>;
declare function sendEmail(to: string, subject: string): void;

async function fulfillOrder(order: Order): Promise<Result<Order, Error>> {
  return Result.Ok(order)
    .flatMap(validateOrder)
    .tap((o: Order) => console.log(`Validated: ${o.id}`))
    .flatMap(chargePayment)
    .tap((o: Order) => sendEmail(o.email, `Order ${o.id} confirmed`))
    .tapErr((e: Error) => console.error(`Failed: ${e.message}`))
    .toPromise();
}

import { Result } from "@carbonteq/fp";

type Session = { userId: string; token: string };

declare function getFromRedis(key: string): Result<Session, Error>;
declare function getFromDatabase(key: string): Result<Session, Error>;

function createGuestSession(): Session {
  return { userId: "guest", token: "guest-token" };
}

function getSession(sessionId: string): Result<Session, Error> {
  return getFromRedis(sessionId)
    .tapErr((e: Error) => console.log(`Redis miss: ${e.message}`))
    .orElse(() => getFromDatabase(sessionId))
    .tapErr((e: Error) => console.log(`DB miss: ${e.message}`))
    .orElse(() => Result.Ok(createGuestSession()));
}

import { Result } from "@carbonteq/fp";

type User = { name: string };
type Prefs = { theme: string };

declare function fetchUser(id: string): Promise<Result<User, Error>>;
declare function fetchPrefs(id: string): Promise<Result<Prefs, Error>>;

async function loadDashboard(userId: string) {
  const [userRes, prefsRes] = await Promise.all([
    fetchUser(userId),
    fetchPrefs(userId),
  ]);

  return Result.all(userRes, prefsRes).map(([user, prefs]) => ({
    userName: user.name,
    theme: prefs.theme,
  }));
}

import { Result } from "@carbonteq/fp";

type Config = { apiUrl: string };

declare function loadFromEnv(): Result<Config, Error>;
declare function loadFromFile(): Result<Config, Error>;
declare function loadFromRemote(): Result<Config, Error>;

function getConfig(): Result<Config, Error[]> {
  return Result.any(loadFromEnv(), loadFromFile(), loadFromRemote());
}