@internetarchive/ia-book-actions 1.4.4-alpha2 → 1.4.4-alpha4

package/package.json

@@ -7,7 +7,7 @@
   },
   "author": "Internet Archive",
   "license": "AGPL-3.0-only",
-  "version": "1.4.4-alpha2",
+  "version": "1.4.4-alpha4",
   "main": "index.js",
   "module": "index.js",
   "publishConfig": {

package/src/ia-book-actions.js

@@ -96,6 +96,15 @@ export default class IABookActions extends LitElement {
 
     this.loanRenewInProgress = false;
 
+    /**
+     * True while a renewal in flight is recovering from a loan that
+     * genuinely lapsed (set by autoRenewExpiredLoan), as opposed to a
+     * routine pre-expiry top-up. Only the recovery case needs BookReader
+     * re-initialized once the renewal is confirmed — see
+     * handleLoanAutoRenewed.
+     */
+    this.recoveringFromLoanExpiry = false;
+
     this.warningModalOpen = false;
 
     /**
@@ -290,10 +299,19 @@ export default class IABookActions extends LitElement {
 
     /**
      * tokenPoller determines if user has loan token for this book
-     * - if book is going to renew, need to wait until renew is completed
+     * - if book is going to renew, need to wait until renew is completed:
+     *   loanRenewInProgress is set before renew_loan is even dispatched
+     *   (including the optimistic pre-confirmation window) and only
+     *   clears once the renewal is confirmed, so starting the poller here
+     *   mid-renewal would call create_token against the loan record
+     *   before it's actually renewed.
      */
     setTimeout(() => {
-      if (!hasExpired && !window.IALendingIntervals.tokenPoller)
+      if (
+        !hasExpired &&
+        !this.loanRenewInProgress &&
+        !window.IALendingIntervals.tokenPoller
+      )
         this.startLoanTokenPoller();
     }, 100);
 
@@ -412,6 +430,7 @@ export default class IABookActions extends LitElement {
   autoRenewExpiredLoan() {
     if (this.loanRenewInProgress) return;
     this.loanRenewInProgress = true;
+    this.recoveringFromLoanExpiry = true;
 
     this.modal?.closeModal();
 
@@ -656,6 +675,7 @@ export default class IABookActions extends LitElement {
     const activeLoan = detail?.data?.loan;
     const errorMessage = `Whoops, seems we hit a hiccup with renewing this book. Please refresh & retry. --- (Debug: ${detail?.data?.error})`;
     if (!activeLoan) {
+      this.recoveringFromLoanExpiry = false;
       this.showErrorModal(errorMessage, 'handleLoanAutoRenewed');
       return;
     }
@@ -678,6 +698,18 @@ export default class IABookActions extends LitElement {
         ajaxResponse: detail?.data,
       });
 
+      if (this.recoveringFromLoanExpiry) {
+        // The loan genuinely lapsed, and renew_loan has now CONFIRMED it's
+        // renewed server-side — only now is it safe to let BookReader
+        // re-initialize (create_token was minting its access cookie off
+        // the loan's expiry; doing this before confirmation risked reading
+        // the still-expired record). loanRenewInProgress already kept the
+        // token poller from restarting early, so it'll pick up fresh here
+        // once lendingStatus below re-triggers setupLendingToolbarActions().
+        this.postInitComplete = false;
+        this.recoveringFromLoanExpiry = false;
+      }
+
       const currStatus = {
         ...this.lendingStatus,
         user_has_browsed: true,
@@ -899,14 +931,24 @@ export default class IABookActions extends LitElement {
   handleLendingActionError(event) {
     this.disableActionGroup = false;
 
-    // clear all intervals for lending system when error occured
-    window?.IALendingIntervals?.clearAll();
-
     const action = event?.detail?.action;
     const errorMsg = event?.detail?.data?.error;
 
+    // A create_token hiccup only affects BookReader's page-image access
+    // token — it says nothing about how much time is left on the loan
+    // itself, so it must not stop the reading countdown. Only clear the
+    // token poller so it can be retried. Every other action failure
+    // (renew_loan, browse_book, etc.) genuinely affects loan state, so it
+    // still clears everything as before.
+    if (action === 'create_token') {
+      window?.IALendingIntervals?.clearTokenPoller();
+    } else {
+      window?.IALendingIntervals?.clearAll();
+    }
+
     if (action === 'renew_loan') {
       this.loanRenewInProgress = false;
+      this.recoveringFromLoanExpiry = false;
     }
 
     // For renew_loan failures after auto-renew, show the patron-facing message

package/test/ia-book-actions.test.js

@@ -689,6 +689,149 @@ describe('autoRenewExpiredLoan', () => {
     expect(el.loanRenewInProgress).to.be.false;
   });
 
+  it('does not reset postInitComplete until renewal is confirmed, not on the optimistic flip (WEBDEV-8322 follow-up)', async () => {
+    // Regression: resetting postInitComplete (which lets BookReader
+    // re-initialize via create_token) as soon as autoRenewExpiredLoan()
+    // optimistically flips browsingExpired would let create_token race
+    // ahead of renew_loan's response, reading the still-expired loan
+    // record and minting a bad access cookie — breaking page images with
+    // CORS/auth errors until the next natural token refresh.
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: {
+          user_has_browsed: true,
+          browsingExpired: true,
+        },
+      })
+    );
+    await el.updateComplete;
+    el.postInitComplete = true;
+    el.lendingBarPostInit = Sinon.spy();
+
+    await el.localCache.set({
+      key: 'foobar-loanTime',
+      value: new Date(new Date().getTime() + 3600 * 1000),
+      ttl: 3600,
+    });
+
+    el.autoRenewExpiredLoan();
+    await el.updateComplete;
+
+    // Still true right after the optimistic flip — must not reset early.
+    expect(el.postInitComplete).to.be.true;
+    expect(el.lendingBarPostInit.called).to.be.false;
+
+    await aTimeout(50);
+
+    const collapsibleActionGroupEl = el.shadowRoot.querySelector(
+      'collapsible-action-group'
+    );
+    collapsibleActionGroupEl.dispatchEvent(
+      new CustomEvent('loanAutoRenewed', {
+        detail: { data: { loan: { identifier: 'foobar' } } },
+      })
+    );
+
+    await aTimeout(100);
+    await el.updateComplete;
+
+    // The confirmed renewal must have forced a fresh create_token cycle
+    // that re-ran lendingBarPostInit() (BookReader re-init) — postInitComplete
+    // itself ends up true again once that cycle completes, so we assert on
+    // the re-init actually having fired instead of the transient flag.
+    expect(el.lendingBarPostInit.calledOnce).to.be.true;
+    expect(el.recoveringFromLoanExpiry).to.be.false;
+  });
+
+  it('does not start the token poller (create_token) on the optimistic flip, only after renewal is confirmed', async () => {
+    // Regression: even without re-running lendingBarPostInit early, the
+    // token poller restart in setupLendingToolbarActions() was ungated —
+    // it fired on the optimistic lendingStatus flip too, calling
+    // create_token against the still-expired loan. When that failed,
+    // handleLendingActionError cleared ALL lending intervals (including
+    // the countdown timer) and flipped user_has_browsed false, sometimes
+    // permanently killing the countdown if it lost the race against the
+    // real renewal confirming afterward.
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: {
+          user_has_browsed: true,
+          browsingExpired: true,
+        },
+      })
+    );
+    await el.updateComplete;
+
+    await el.localCache.set({
+      key: 'foobar-loanTime',
+      value: new Date(new Date().getTime() + 3600 * 1000),
+      ttl: 3600,
+    });
+
+    const startTokenPollerSpy = Sinon.spy(el, 'startLoanTokenPoller');
+
+    el.autoRenewExpiredLoan();
+    await el.updateComplete;
+    await aTimeout(150); // let the 100ms token-poller-restart check run
+
+    expect(startTokenPollerSpy.called).to.be.false;
+
+    await aTimeout(50);
+    const collapsibleActionGroupEl = el.shadowRoot.querySelector(
+      'collapsible-action-group'
+    );
+    collapsibleActionGroupEl.dispatchEvent(
+      new CustomEvent('loanAutoRenewed', {
+        detail: { data: { loan: { identifier: 'foobar' } } },
+      })
+    );
+
+    await aTimeout(200);
+    await el.updateComplete;
+
+    expect(startTokenPollerSpy.calledOnce).to.be.true;
+  });
+
+  it('does not touch postInitComplete on a routine (non-expiry) renewal', async () => {
+    // A background top-up renewal (loan never actually lapsed) never
+    // interrupted BookReader, so it must not force a re-init.
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: { user_has_browsed: true, browsingExpired: false },
+      })
+    );
+    await el.updateComplete;
+    el.postInitComplete = true;
+    el.loanRenewResult = { texts: '', renewNow: true, renewType: 'auto' };
+    el.lendingBarPostInit = Sinon.spy();
+
+    await el.localCache.set({
+      key: 'foobar-loanTime',
+      value: new Date(new Date().getTime() + 3600 * 1000),
+      ttl: 3600,
+    });
+
+    const collapsibleActionGroupEl = el.shadowRoot.querySelector(
+      'collapsible-action-group'
+    );
+    collapsibleActionGroupEl.dispatchEvent(
+      new CustomEvent('loanAutoRenewed', {
+        detail: { data: { loan: { identifier: 'foobar' } } },
+      })
+    );
+
+    await aTimeout(100);
+    await el.updateComplete;
+
+    expect(el.lendingBarPostInit.called).to.be.false;
+  });
+
   it('clears loanRenewInProgress and shows unavailable modal on renew_loan failure', async () => {
     const el = await fixture(
       container({
@@ -783,6 +926,60 @@ describe('handleLendingActionError - loanRenewInProgress reset', () => {
   });
 });
 
+describe('handleLendingActionError - create_token failures must not stop the countdown (WEBDEV-8322 follow-up)', () => {
+  it('does not clear the reading countdown on a create_token failure', async () => {
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: {
+          user_has_browsed: true,
+          browsingExpired: false,
+          secondsLeftOnLoan: 100,
+        },
+      })
+    );
+    await el.updateComplete;
+    expect(window.IALendingIntervals.timerCountdown).to.not.equal(0);
+
+    el.handleLendingActionError({
+      detail: {
+        action: 'create_token',
+        data: { error: 'loan token not found. please try again later.' },
+      },
+    });
+
+    // The countdown must keep running — a token refresh hiccup says
+    // nothing about how much time is left on the loan itself.
+    expect(window.IALendingIntervals.timerCountdown).to.not.equal(0);
+  });
+
+  it('still clears everything on a renew_loan failure', async () => {
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: {
+          user_has_browsed: true,
+          browsingExpired: false,
+          secondsLeftOnLoan: 100,
+        },
+      })
+    );
+    await el.updateComplete;
+    expect(window.IALendingIntervals.timerCountdown).to.not.equal(0);
+
+    el.handleLendingActionError({
+      detail: {
+        action: 'renew_loan',
+        data: { error: 'some other unrelated failure' },
+      },
+    });
+
+    expect(window.IALendingIntervals.timerCountdown).to.equal(0);
+  });
+});
+
 describe('showWarningModal', () => {
   it('shows a headline, one Okay button, and an info-icon help link; Okay dismisses without renewing', async () => {
     const el = await fixture(