@internetarchive/ia-book-actions 1.4.4-alpha15 → 1.4.4-alpha17

package/package.json

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

package/src/core/services/actions-handler/actions-handler-service.js

@@ -117,8 +117,5 @@ export default async function ActionsHandlerService(options) {
      * connection is exactly when this fires.
      */
     log(`[IABookActions] ✗ ${option.action} threw`, error);
-    option?.error({
-      error: `Could not reach the lending service. Please check your connection and try again. (${error})`,
-    });
   }
 }

package/src/core/services/loan-token-poller.js

@@ -10,12 +10,46 @@ import log from './log.js';
  * ActionsHandlerService is a function being used to execute
  */
 export class LoanTokenPoller {
-  constructor(id, borrowType, successCallback, errorCallback, pollerDelay) {
-    this.identifier = id;
+  /**
+   * @param {Object} options
+   * @param {string} options.identifier
+   * @param {string} options.borrowType
+   * @param {Function} options.successCallback - called after the initial
+   *   loan token is created.
+   * @param {Function} options.errorCallback - called on any create_token
+   *   failure (initial or a routine interval tick).
+   * @param {number} options.pollerDelay - interval between routine
+   *   create_token checks, in seconds.
+   * @param {boolean} [options.skipInitialCall] - skip the immediate
+   *   create_token call, only start the recurring interval. Used after a
+   *   loan-expiry recovery renewal, where BookLoanService::
+   *   attempt_to_renew_loan() already minted a valid access token as part
+   *   of the renew_loan response itself — an immediate confirming
+   *   create_token call is redundant.
+   * @param {Function} [options.onTokenRefreshed] - called after EVERY
+   *   successful create_token, initial or routine — unlike successCallback,
+   *   which only fires for the initial one. Lets the consumer retry any
+   *   page image that failed during a prior access gap, now that access is
+   *   confirmed good again.
+   */
+  constructor(options = {}) {
+    const {
+      identifier,
+      borrowType,
+      successCallback,
+      errorCallback,
+      pollerDelay,
+      skipInitialCall = false,
+      onTokenRefreshed,
+    } = options;
+
+    this.identifier = identifier;
     this.borrowType = borrowType;
     this.successCallback = successCallback; // callback function to be called after loan token is created
     this.errorCallback = errorCallback; // callback function to be called after loan token is created
     this.pollerDelay = pollerDelay; // value in seconds
+    this.skipInitialCall = skipInitialCall === true;
+    this.onTokenRefreshed = onTokenRefreshed;
 
     this.loanTokenInterval = undefined;
 
@@ -34,8 +68,14 @@ export class LoanTokenPoller {
 
   async bookAccessed() {
     if (this.borrowType) {
-      // Do an initial token, then set an interval
-      this.handleLoanTokenPoller(true);
+      if (this.skipInitialCall) {
+        log('[LoanTokenPoller] skipping initial create_token — already minted by the renewal response', {
+          identifier: this.identifier,
+        });
+      } else {
+        // Do an initial token, then set an interval
+        this.handleLoanTokenPoller(true);
+      }
 
       // if this.borrowType = adminBorrowed,
       // - we don't want to fetch token on interval
@@ -78,6 +118,7 @@ export class LoanTokenPoller {
           identifier: this.identifier,
           isInitial,
         });
+        this.onTokenRefreshed?.();
         if (isInitial) this.successCallback();
       },
     });

package/src/ia-book-actions.js

@@ -55,6 +55,10 @@ export default class IABookActions extends LitElement {
         type: Function,
         attribute: false,
       },
+      reloadPageImages: {
+        type: Function,
+        attribute: false,
+      },
       barType: { type: String },
       sharedObserver: { attribute: false },
       disableActionGroup: { type: Boolean },
@@ -77,6 +81,7 @@ export default class IABookActions extends LitElement {
     this.width = 0;
     this.bwbPurchaseUrl = '';
     this.lendingBarPostInit = () => {};
+    this.reloadPageImages = () => {};
     this.barType = 'action'; // 'title'|'action'
     this.sharedObserver = undefined;
     this.disableActionGroup = false;
@@ -104,6 +109,15 @@ export default class IABookActions extends LitElement {
      */
     this.recoveringFromLoanExpiry = false;
 
+    /**
+     * True right after a confirmed renewal (any kind), until the token
+     * poller restarts. renew_loan's own response already carries a valid
+     * access token, so that restart should skip its normal immediate
+     * create_token call — see handleLoanAutoRenewed/
+     * setupLendingToolbarActions.
+     */
+    this.skipNextInitialTokenCall = false;
+
     this.warningModalOpen = false;
 
     /** Once dismissed, don't re-show the warning modal every tick — only
@@ -318,8 +332,14 @@ export default class IABookActions extends LitElement {
         !this.loanRenewInProgress &&
         !window.IALendingIntervals.tokenPoller
       ) {
+        // Any confirmed renewal's response already minted a valid access
+        // token (see handleLoanAutoRenewed) — the poller only needs to
+        // start its recurring check, not fire an immediate confirming
+        // create_token call too.
+        const skipInitialCall = this.skipNextInitialTokenCall;
+        this.skipNextInitialTokenCall = false;
         this.recoveringFromLoanExpiry = false;
-        this.startLoanTokenPoller();
+        this.startLoanTokenPoller(skipInitialCall);
       }
     }, 100);
   }
@@ -740,10 +760,28 @@ export default class IABookActions extends LitElement {
         ajaxResponse: detail?.data,
       });
 
+      // BookLoanService::attempt_to_renew_loan() mints a valid access
+      // token as part of EVERY renew_loan response, not just a recovery
+      // from expiry — so the poller restart below never needs to fire a
+      // redundant confirming create_token call, regardless of which path
+      // triggered this renewal.
+      this.skipNextInitialTokenCall = true;
+
+      // Retry any page image that failed during the gap this renewal just
+      // closed, right away rather than waiting for the next routine
+      // create_token tick (up to tokenDelay seconds away, now that the
+      // initial one above is skipped).
+      this.reloadPageImages();
+
       if (this.recoveringFromLoanExpiry) {
         // Only now is it safe to re-initialize BookReader — not for a
-        // routine top-up, where that would be disruptive.
-        this.postInitComplete = false;
+        // routine top-up, where that would be disruptive. Call it
+        // directly rather than waiting on a confirming create_token
+        // success: BookLoanService::attempt_to_renew_loan() already
+        // minted a valid access token as part of this renew_loan
+        // response, so there's nothing left to confirm.
+        this.lendingBarPostInit();
+        this.postInitComplete = true;
       }
 
       const currStatus = {
@@ -895,9 +933,10 @@ export default class IABookActions extends LitElement {
 
   /**
    * enable access of borrowed/browsed books
+   * @param {boolean} [skipInitialCall] - see LoanTokenPoller's constructor doc
    * @see LoanTokenPoller
    */
-  startLoanTokenPoller() {
+  startLoanTokenPoller(skipInitialCall = false) {
     const successCallback = () => {
       if (!this.postInitComplete) {
         this.lendingBarPostInit();
@@ -907,17 +946,26 @@ export default class IABookActions extends LitElement {
     const errorCallback = eventObj => {
       this.handleLendingActionError(eventObj);
     };
+    // BookReader has no self-healing for a page <img> that failed while
+    // access was briefly invalid — retry any of those now that this
+    // create_token confirms access is good again, on every success, not
+    // just the initial one.
+    const onTokenRefreshed = () => {
+      this.reloadPageImages();
+    };
 
     // Tear down any previous poller first, so only one is ever controlling
     // window.IALendingIntervals.tokenPoller at a time.
     this.tokenPoller?.disconnectedCallback();
-    this.tokenPoller = new LoanTokenPoller(
-      this.identifier,
-      this.borrowType,
+    this.tokenPoller = new LoanTokenPoller({
+      identifier: this.identifier,
+      borrowType: this.borrowType,
       successCallback,
       errorCallback,
-      this.tokenDelay // in seconds
-    );
+      pollerDelay: this.tokenDelay, // in seconds
+      skipInitialCall,
+      onTokenRefreshed,
+    });
   }
 
   /*
@@ -1101,6 +1149,10 @@ export default class IABookActions extends LitElement {
         justify-content: center;
         flex-wrap: wrap;
       }
+
+      #action-bar-modal {
+        --modalWidth: 36rem;
+      }
     `;
   }
 }

package/test/core/services/loan-token-poller.test.js

@@ -1,4 +1,4 @@
-import { expect } from '@open-wc/testing';
+import { expect, aTimeout } from '@open-wc/testing';
 import Sinon from 'sinon';
 
 import { LoanTokenPoller } from '../../../src/core/services/loan-token-poller.js';
@@ -17,18 +17,17 @@ afterEach(() => {
 
 describe('Get Loan Token', () => {
   it('get loan token for browsed books', async () => {
-    // id, borrowType, successCallback, errorCallback, pollerDelay
-    const tokenPoller = new LoanTokenPoller(
-      'identifier1',
-      'browsed',
-      () => {
+    const tokenPoller = new LoanTokenPoller({
+      identifier: 'identifier1',
+      borrowType: 'browsed',
+      successCallback: () => {
         console.log('success callback is executed!');
       },
-      () => {
+      errorCallback: () => {
         console.log('error callback is executed!');
       },
-      2000 // 2 minutes'
-    );
+      pollerDelay: 2000, // 2 minutes'
+    });
     const successCallbackSpy = Sinon.stub(tokenPoller, 'successCallback');
     successCallbackSpy();
     expect(successCallbackSpy.callCount).to.equal(1);
@@ -39,13 +38,13 @@ describe('Get Loan Token', () => {
   });
 
   it('get loan token for admin borrowed books', async () => {
-    const tokenPoller = new LoanTokenPoller(
-      'identifier1',
-      'adminBorrowed',
-      () => {},
-      () => {},
-      2000 // 2 minutes'
-    );
+    const tokenPoller = new LoanTokenPoller({
+      identifier: 'identifier1',
+      borrowType: 'adminBorrowed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 2000, // 2 minutes'
+    });
 
     const successCallbackSpy = Sinon.stub(tokenPoller, 'successCallback');
     successCallbackSpy();
@@ -61,13 +60,13 @@ describe('handleTokenError (no retry)', () => {
   // A create_token failure is treated as terminal on the first attempt —
   // no retry, whether it's the "stale loan read" race or anything else.
   const makeTokenPoller = () =>
-    new LoanTokenPoller(
-      'identifier1',
-      'browsed',
-      () => {},
-      () => {},
-      2000
-    );
+    new LoanTokenPoller({
+      identifier: 'identifier1',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 2000,
+    });
 
   it('reports the error immediately, without retrying, on the initial call', () => {
     const tokenPoller = makeTokenPoller();
@@ -100,7 +99,13 @@ describe('handleTokenError (no retry)', () => {
 
   it('passes isInitial through to the error callback', () => {
     const errorCallback = Sinon.spy();
-    const poller = new LoanTokenPoller('foo', 'browsed', () => {}, errorCallback, 120);
+    const poller = new LoanTokenPoller({
+      identifier: 'foo',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback,
+      pollerDelay: 120,
+    });
     poller.disconnectedCallback();
 
     poller.handleTokenError({ error: 'something else went wrong' }, true);
@@ -109,3 +114,83 @@ describe('handleTokenError (no retry)', () => {
     expect(errorCallback.firstCall.args[0].detail.isInitial).to.be.true;
   });
 });
+
+describe('skipInitialCall option', () => {
+  it('starts the recurring interval but fires no immediate create_token call', () => {
+    const poller = new LoanTokenPoller({
+      identifier: 'foo',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 120,
+      skipInitialCall: true,
+    });
+    const handleLoanTokenPollerSpy = Sinon.spy(poller, 'handleLoanTokenPoller');
+
+    // bookAccessed() already ran in the constructor above (before the spy
+    // was attached) -- re-run it to observe whether it calls out.
+    poller.bookAccessed();
+
+    expect(handleLoanTokenPollerSpy.called).to.be.false;
+    expect(window.IALendingIntervals.tokenPoller).to.not.equal(0);
+    poller.disconnectedCallback();
+  });
+
+  it('fires the immediate call as usual when skipInitialCall is not set', () => {
+    const poller = new LoanTokenPoller({
+      identifier: 'foo',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 120,
+    });
+    const handleLoanTokenPollerSpy = Sinon.spy(poller, 'handleLoanTokenPoller');
+
+    poller.bookAccessed();
+
+    expect(handleLoanTokenPollerSpy.calledWith(true)).to.be.true;
+    poller.disconnectedCallback();
+  });
+});
+
+describe('onTokenRefreshed option', () => {
+  // BookReader has no self-healing for a page <img> that failed while
+  // access was briefly invalid, so the consumer needs a signal on EVERY
+  // create_token success (not just the initial one) to know it's safe to
+  // retry those images.
+  it('fires on the initial create_token success', async () => {
+    const onTokenRefreshed = Sinon.spy();
+    const poller = new LoanTokenPoller({
+      identifier: 'foo',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 120,
+      onTokenRefreshed,
+    });
+
+    await aTimeout(50);
+
+    expect(onTokenRefreshed.called).to.be.true;
+    poller.disconnectedCallback();
+  });
+
+  it('fires on a routine (non-initial) create_token success too', async () => {
+    const onTokenRefreshed = Sinon.spy();
+    const poller = new LoanTokenPoller({
+      identifier: 'foo',
+      borrowType: 'browsed',
+      successCallback: () => {},
+      errorCallback: () => {},
+      pollerDelay: 120,
+      onTokenRefreshed,
+    });
+    onTokenRefreshed.resetHistory();
+
+    await poller.handleLoanTokenPoller(false);
+    await aTimeout(50);
+
+    expect(onTokenRefreshed.called).to.be.true;
+    poller.disconnectedCallback();
+  });
+});

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

@@ -479,8 +479,7 @@ describe('Browsing expired status', () => {
   });
 });
 
-describe('Auto renew one hour loan', async () => {
-  await aTimeout(5000);
+describe('Auto renew one hour loan', () => {
   it('Book is browsing and renewed it now', async () => {
     const loanTime = 88;
     const el = await fixture(
@@ -553,8 +552,7 @@ describe('Auto renew one hour loan', async () => {
   });
 });
 
-describe('Visibility change API for document', async () => {
-  await aTimeout(5000);
+describe('Visibility change API for document', () => {
 
   beforeEach(() => {
     Object.defineProperty(document, 'hidden', {
@@ -578,6 +576,10 @@ describe('Visibility change API for document', async () => {
         lendingStatus: {
           user_has_browsed: true,
           browsingExpired: false,
+          // Without this, startBrowseTimer() computes setTimeout(fn,
+          // undefined * 1000) -> NaN, which fires almost immediately and
+          // expires the loan before this test ever dispatches its event.
+          secondsLeftOnLoan: 3600,
         },
       })
     );
@@ -605,6 +607,7 @@ describe('Visibility change API for document', async () => {
         lendingStatus: {
           user_has_browsed: true,
           browsingExpired: false,
+          secondsLeftOnLoan: 3600,
         },
       })
     );
@@ -940,6 +943,106 @@ describe('autoRenewExpiredLoan', () => {
     expect(el.lendingBarPostInit.called).to.be.false;
   });
 
+  it('also skips the initial create_token after a routine (non-expiry) renewal', async () => {
+    // BookLoanService::attempt_to_renew_loan() mints the access token as
+    // part of EVERY renew_loan response, not just a recovery from expiry.
+    // A routine top-up also has its poller stopped mid-renewal (see
+    // updated()'s clearAll() on loanRenewResult.renewNow), so it would
+    // otherwise fire this same redundant call once the poller restarts.
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: { user_has_browsed: true, browsingExpired: false },
+      })
+    );
+    await el.updateComplete;
+    el.postInitComplete = true;
+    el.reloadPageImages = Sinon.spy();
+
+    await el.localCache.set({
+      key: 'foobar-loanTime',
+      value: new Date(new Date().getTime() + 3600 * 1000),
+      ttl: 3600,
+    });
+
+    const startTokenPollerSpy = Sinon.spy(el, 'startLoanTokenPoller');
+
+    // Triggers updated()'s clearAll(), stopping the running poller, same
+    // as a real routine top-up would.
+    el.loanRenewResult = { texts: '', renewNow: true, renewType: 'auto' };
+    await el.updateComplete;
+
+    const collapsibleActionGroupEl = el.shadowRoot.querySelector(
+      'collapsible-action-group'
+    );
+    collapsibleActionGroupEl.dispatchEvent(
+      new CustomEvent('loanAutoRenewed', {
+        detail: { data: { loan: { identifier: 'foobar', renewal: true } } },
+      })
+    );
+
+    await aTimeout(200);
+    await el.updateComplete;
+
+    expect(startTokenPollerSpy.calledOnceWith(true)).to.be.true;
+    // Retried right away rather than waiting for the (now-skipped) initial
+    // create_token or the next routine tick.
+    expect(el.reloadPageImages.called).to.be.true;
+  });
+
+  it('calls lendingBarPostInit directly on a recovery renewal and skips the initial create_token', async () => {
+    // BookLoanService::attempt_to_renew_loan() now mints the access token
+    // as part of the renew_loan response itself (using the just-written
+    // loan record already in memory, not a separate read) -- so recovering
+    // from a genuine expiry no longer needs to wait on a confirming
+    // create_token success before re-initializing BookReader, and the
+    // poller it starts afterward shouldn't fire a redundant immediate call.
+    const el = await fixture(
+      container({
+        userid: '@user1',
+        identifier: 'foobar',
+        lendingStatus: {
+          user_has_browsed: true,
+          browsingExpired: true,
+        },
+      })
+    );
+    await el.updateComplete;
+    el.lendingBarPostInit = Sinon.spy();
+    el.reloadPageImages = Sinon.spy();
+
+    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(50); // let autoRenewExpiredLoan's setTimeout(0) set renewNow
+
+    await el.handleLoanAutoRenewed({
+      detail: {
+        action: 'renew_loan',
+        data: { success: true, loan: { identifier: 'foobar', renewal: true } },
+      },
+    });
+
+    // Called synchronously from handleLoanAutoRenewed, not via a
+    // create_token success callback.
+    expect(el.lendingBarPostInit.calledOnce).to.be.true;
+    expect(el.postInitComplete).to.be.true;
+    expect(el.reloadPageImages.called).to.be.true;
+
+    await el.updateComplete;
+    await aTimeout(150); // let the 100ms token-poller-restart check run
+
+    expect(startTokenPollerSpy.calledOnceWith(true)).to.be.true;
+  });
+
   it('clears loanRenewInProgress and shows unavailable modal on renew_loan failure', async () => {
     const el = await fixture(
       container({