TS/F#

Result.ts

export interface ErrorValue {
  ErrorValue: string;
}

export interface ResultValue<T> {
  ResultValue: T;
}

export interface ErrorResult {
  Case: "Error";
  Fields: ErrorValue;
}

export interface OkResult<T> {
  Case: "Ok";
  Fields: ResultValue<T>;
}

export type Result<T> = OkResult<T> | ErrorResult;

export const handleResultType = <T>(
  data: Result<T>,
  okCallBack: (_: T) => void,
  errorCallBack: (_: string) => void
) => {
  switch (data.Case) {
    case "Ok":
      return okCallBack(data.Fields.ResultValue);
    case "Error":
      return errorCallBack(data.Fields.ErrorValue);
  }
};
  
//usage
login()
  .then((response) => response.json() as Promise<Result<Token>>)
  .then((data) => {
    handleResultType(
      data,
      (okValue: Token) => {
        console.log("OK", okValue);
      },
      (error) => {
        console.log("ERROR", error);
      }
    );
  });

type.fs

type CreateUserRequest =
    { Email: string
      Password: string
      PasswordConfirmation: string }

type.ts

type CreateUserRequest = {
  Email: string;
  Password: string;
  PasswordConfirmation: string;
};

if you want to go the full promise way I'd suggest something like this in the handleResultType

export const handleResultType = <T>(data: Result<T>) => {
  switch (data.Case) {
    case "Ok":
      return Promise.resolve(data.Fields.ResultValue);
    case "Error":
      return Promise.reject(data.Fields.ErrorValue);
  }
};

it should work somewhat like this (just wrote it from memory didn't test it)

login()
  .then((response) => response.json() as Promise<Result<Token>>)
  .then(handleResultType)
  .then((okValue: Token) => {
    console.log("OK", okValue);
  })
  .catch((error) => {
    console.log("ERROR", error);
  });

and it also should save you from nesting callbacks

Thanks, that looks a lot cleaner 👍