Using a proxy for persistence in TypeScript

bank.ts

class Account {}

interface Bank {
  getAccounts(): Account[]
  setAccounts(accounts: Account[]): void
}

// "Plain Old JavaScript Object" implementing abstraction
class BankImpl implements Bank {
  private accounts: Account[];

  getAccounts(): Account[] {
    return this.accounts;
  }

  setAccounts(accounts: Account[]): void {
    this.accounts = [];
    accounts.forEach(account => this.accounts.push(account));
  }
}

// Bank Proxy
class BankProxyHandler {
  private proxy: Bank;

  private constructor(bank: Bank) {
    this.proxy = new Proxy(bank, this);
  }

  public static invoke(bank: Bank) {
    return new BankProxyHandler(bank).proxy;
  }

  get(bank: Bank, methodName: string) {
    return (accounts: Account[]) => {
      if (methodName === 'getAccounts') {
        bank.setAccounts(this.getAccountsFromDatabase());
        return bank.getAccounts();
      }
      if (methodName === 'setAccounts') {
        bank.setAccounts(accounts);
        this.setAccountsToDatabase(bank.getAccounts());
        return null;
      }
      throw Error('Invalid method');
    }
  }

  protected getAccountsFromDatabase(): Account[] {
    console.log('I was called');
    return []
  }

  protected setAccountsToDatabase(accounts: Account[]): void {
    console.log('So was I');
  }
}

const bank: Bank = BankProxyHandler.invoke(new BankImpl);
const accounts: Account[] = bank.getAccounts(); // I was called
bank.setAccounts(accounts); // So was I