The accepted answer is actually not answering the question since it was asked for a generic way.

Here is one that is similar and will also cast the return type properly:

type RecursivelyReplaceNullWithUndefined<T> = T extends null
  ? undefined
  : T extends Date
  ? T
  : {
      [K in keyof T]: T[K] extends (infer U)[]
        ? RecursivelyReplaceNullWithUndefined<U>[]
        : RecursivelyReplaceNullWithUndefined<T[K]>;
    };

export function nullsToUndefined<T>(obj: T): RecursivelyReplaceNullWithUndefined<T> {
  if (obj === null) {
    return undefined as any;
  }

  // object check based on: https://stackoverflow.com/a/51458052/6489012
  if (obj.constructor.name === "Object") {
    for (let key in obj) {
      obj[key] = nullsToUndefined(obj[key]) as any;
    }
  }
  return obj as any;
}

Credits go to the typings of this genius: https://github.com/apollographql/apollo-client/issues/2412#issuecomment-755449680

Javascript now supports a null-coalescing operator: ??. It may not be production-ready (consult the support table), but it's certainly safe to use with Node or a transpiler (TypeScript, Babel, etc.).

Per MDN,

The nullish coalescing operator (??) is a logical operator that returns its right-hand side operand when its left-hand side operand is null or undefined, and otherwise returns its left-hand side operand.

Much as || can provide a "default" value when the left operand is falsey, ?? provides a "default" value if the left operand is null or undefined. You can use this to coerce undefined to null:

    // OR operator can coerce 'defined' values
    "value"   || null;    // "value"
    0         || null;    // null
    false     || null;    // null
    ""        || null;    // null
    undefined || null;    // null
    
    // The null-coalescing operator will only coerce undefined or null
    "value"   ?? null;    // "value"
    0         ?? null;    // 0
    false     ?? null;    // false
    ""        ?? null;    // ""
    undefined ?? null;    // null

An example based on the question:

    function mustNotReturnUndefined(mightBeUndefined) { // can return null
        // Substitute empty string for null or undefined
        let result = processValue(mightBeUndefined ?? "");

        // Substitute null for undefined
        return result ?? null;
    }

This post explains the differences very well. They are the same in TypeScript as in JavaScript.

As for what you should use: You may define that on your own. You may use either, just be aware of the differences and it might make sense to be consistent.

The TypeScript coding style guide for the TypeScript source code (not an official "how to use TypeScript" guide) states that you should always use undefined and not null: Typescript Project Styleguide.