Make the type of the return value more precise

[slaweet]

If the first return value (error) is null, then this change implies that the second return value is not undefined.

It solves a problem I was facing: getting Type 'APIResponse<any> | undefined' is not assignable to type 'APIResponse<any>' type error on the last row of the following Vuex (with vuex-module-decorators) example:

    @Action({ rawError: true })
    public async deleteAsset(asset: Asset): Promise<APIResponse> {
      this.context.commit('setIsLoading', true);
      const [err, response] = await to(deleteAsset(asset));
      this.context.commit('setIsLoading', false);
      if (err) {
        throw err;
      }   
      this.context.commit('setAssetDeleted', asset);
      return response;
    }

[ajschmidt8]

@scopsy, can we get this merged?

[karlhorky]

@scopsy ran into problems with this today - what do you think about merging this?

[karlhorky]

@scopsy nice, thanks for the merge! Will this be released in a new version 2.1.2?

[scopsy]

Hi! Yes this will be released in an new minor version. Hopefully today :)

[slaweet]

Hi! Yes this will be released in an new minor version. Hopefully today :)

Great. I'm looking forward to the release.

[mrmartineau]

FYI, this was released yesterday as v3.0.0

[WilliamStephens]

Does this currently work? I'm still having to cast user as UserEntity because the inferred type is
const user: UserEntity | undefined

  createUser = async (userToCreate: Omit<UserEntity, 'id'>): Promise<UserDTO> => {
    const [err, user] = await to(this.UserRepository.createUser(userToCreate));
    if (err) {
      this.Logger.error('Failed to create user.', err.message);
      throw err;
    }

    const userDTO = UserMapper.userEntityToDTO(user as UserEntity);
    return userDTO;
  };

[slaweet]

@WilliamStephens it likely doesn't work. I don't know why. I stopped using await-to-js with typescript because of it.

[karlhorky]

If the types of await-to-js are returning a union like {err: Error} | {user: User}, it would work if you don't destructure.

Destructuring makes TypeScript "forget" about the relationship between the two variables err and user, but if you don't destructure, TypeScript can narrow the type correctly:

const results = await to(this.UserRepository.createUser(userToCreate));
if ('err' in results) {
  this.Logger.error('Failed to create user.', results.err.message);
  throw results.err;
}

const userDTO = UserMapper.userEntityToDTO(results.user); // ✅ results.user = User type
return userDTO;

---

The overarching feature set to allow things like destructuring is described as "Correlated Union Types", which some of the newer (and upcoming) versions of TypeScript support, at least partially:

microsoft/TypeScript#30581

[WilliamStephens]

Hmm, yeah seems like destructuring is whats causing it. I converted the return type to be an object to make it a little more explicit.

export function to<T, U = Error>(
  promise: Promise<T>,
  errorExt?: object
): Promise<{ err: U; data: undefined } | { err: null; data: T }> {
  return promise
    .then((data: T) => ({ err: null, data }))
    .catch((err: U) => {
      if (errorExt) {
        const parsedError = Object.assign({}, err, errorExt);
        return { err: parsedError, data: undefined };
      }

      return { err, data: undefined };
    });
}

Then I can do something like this

  createUser = async (userToCreate: Omit<UserEntity, 'id'>): Promise<UserDTO> => {
    const result = await to(this.UserRepository.createUser(userToCreate));
    if (result.err) {
      this.Logger.error('Failed to create user.', result.err.message);
      throw result.err;
    }

    const userDTO = UserMapper.userEntityToDTO(result.data);
    return userDTO;
  };
}

Instead of doing something like if(results[0]) throw results[0].message

Thanks for the replies!