Using the concept of defer from golang to simplify resource cleanup in Javascript

README.md

The withCleanup helper

Example

const result = await withCleanup(async (defer) => {
  const fileHandle = await getFileHandle();
  defer(() => fileHandle.close());
   
  // Carry on
  
  return fileHandle.read();
});

Usage

The withCleanup accepts a function as an argument. That function will be passed a defer function reference. The defer function is a mechanism to register some clean-up work that will happen at the completion of the function.

The defer function should be called with a function as an argument. This function will be stored and called in LIFO order when the wrapped function's returned promise settles. Errors thrown in clean-up functions will not prevent other clean-up functions from running and will instead be accumulated into an AggregateError and thrown at the end.

lifecycle.ts

type DeferredCleanupFunction = (...args: any[]) => any;
type WithCleanupFunction = (deferredFn: DeferredCleanupFunction) => void;
export async function withCleanup<TFunc extends (defer: WithCleanupFunction) => Promise<any>>(
  func: TFunc
): Promise<ReturnType<TFunc>> {
  const onCleanup: DeferredCleanupFunction[] = [];
  const defer: WithCleanupFunction = (deferredFn) => {
    onCleanup.unshift(deferredFn);
  };

  try {
    return await func(defer);
  } finally {
    let errors = [];
    for (const onCleanupFn of onCleanup) {
      try {
        await onCleanupFn();
      } catch (err) {
        errors.push(err);
      }
    }
    if (errors.length) {
      throw new AggregateError(errors, 'Exceptions caught while executing deferred functions');
    }
  }
}

export class AggregateError extends Error {
  constructor(readonly errors: Iterable<Error>, readonly message: string = '') {
    super(message);
    this.name = 'AggregateError';
  }
}