Implementing forced nullification

src/builder/index.ts

@@ -23,6 +23,7 @@ export async function buildSW(
     documentCachingOptions: {},
   },
   importFrom: string = 'https://cdn.ampproject.org/amp-sw.js',
+  forcedNullifcation: boolean = false,
 ) {
   let code = '';
   if (config.offlinePageOptions && config.offlinePageOptions.url) {
@@ -32,6 +33,9 @@ export async function buildSW(
     );
   }
   code = `importScripts('${importFrom}')\n`;
-  code += `AMP_SW.init(${serializeObject(config || {})})`;
-  return code;
+  if (forcedNullifcation) {
+    return code + 'AMP_SW.forcedNullifcation()';
+  } else {
+    return code + `AMP_SW.init(${serializeObject(config || {})})`;
+  }
 }

src/modules/amp-caching/constants.ts

@@ -0,0 +1,2 @@
+export const UNVERSIONED_CACHE_NAME = 'AMP-UNVERSIONED-CACHE';
+export const VERSIONED_CACHE_NAME = 'AMP-VERSIONED-CACHE';

src/modules/amp-caching/index.ts

@@ -22,12 +22,11 @@ import { CacheFirst, StaleWhileRevalidate } from 'workbox-strategies';
 import { Plugin } from 'workbox-cache-expiration';
 import { FluxStandardAction } from '../flux-standard-actions';
 import { AmpSwModule } from '../core/AmpSwModule';
+import { UNVERSIONED_CACHE_NAME, VERSIONED_CACHE_NAME } from './constants';
 
 const VERSIONED_ASSETS_RE = /^https:\/\/cdn.ampproject.org\/rtv\/\d*\//;
 const UNVERSIONED_RUNTIME_RE = /^https:\/\/cdn.ampproject.org\/\w*(-\w*)?.js/;
 const UNVERSIONED_EXTENSIONS_RE = /^https:\/\/cdn.ampproject.org\/v0\//;
-const UNVERSIONED_CACHE_NAME = 'AMP-UNVERSIONED-CACHE';
-const VERSIONED_CACHE_NAME = 'AMP-VERSIONED-CACHE';
 
 async function cachePreRequestedScripts(scripts: Array<string>) {
   const unversionedScripts: Array<Request> = [];

src/modules/asset-caching/constants.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-export const cacheName = 'AMP-ASSET-CACHE';
+export const AMP_ASSET_CACHE = 'AMP-ASSET-CACHE';

src/modules/asset-caching/index.ts

@@ -24,7 +24,7 @@ import {
 } from 'workbox-strategies';
 // @ts-ignore
 import { Plugin } from 'workbox-cache-expiration';
-import { cacheName } from './constants';
+import { AMP_ASSET_CACHE } from './constants';
 import { AmpSwModule } from '../core/AmpSwModule';
 
 export type AssetCachingOptions = Array<{
@@ -75,7 +75,7 @@ export class AssetCachingAmpModule implements AmpSwModule {
     assetCachingOptions.forEach(assetCachingOption => {
       let cachingStrategy = null;
       const cachingConfig = {
-        cacheName,
+        cacheName: AMP_ASSET_CACHE,
         plugins: [
           new AssetCachingPlugin({
             maxEntries: 25,

src/modules/core/index.ts

@@ -19,10 +19,12 @@ import { ServiceWorkerConfiguration } from '../../configuration';
 import { AssetCachingOptions } from '../asset-caching';
 import { LinkPrefetchOptions } from '../link-prefetch';
 import { OfflinePageOptions } from '../offline-page';
+
 declare global {
   interface WorkerGlobalScope {
     AMP_SW: {
       init: Function;
+      forcedNullifcation: () => void;
     };
   }
 }
@@ -96,7 +98,16 @@ function init(config: ServiceWorkerConfiguration = {}) {
   });
 }
 
+function forcedNullifcation() {
+  import(/* webpackChunkName: "service-worker-remover" */ '../service-worker-remover/index').then(
+    async ({ ServiceWorkerRemover }) => {
+      new ServiceWorkerRemover().installNoOpServiceWorker();
+    },
+  );
+}
+
 // Initialize AMP_SW namespace
 self['AMP_SW'] = {
   init,
+  forcedNullifcation,
 };

src/modules/document-caching/AmpDocumentNetworkFirst.ts

@@ -16,7 +16,7 @@
 
 // @ts-ignore
 import { NetworkFirst } from 'workbox-strategies';
-import { cacheName } from './constants';
+import { AMP_PUBLISHER_CACHE } from './constants';
 
 export class AmpDocumentNetworkFirst extends NetworkFirst {
   _offlineFallbackUrl?: string;
@@ -35,7 +35,7 @@ export class AmpDocumentNetworkFirst extends NetworkFirst {
   }) {
     let response = await super.makeRequest({ event, request });
     if (!response && this._offlineFallbackUrl) {
-      const cache = await caches.open(cacheName);
+      const cache = await caches.open(AMP_PUBLISHER_CACHE);
       response = await cache.match(this._offlineFallbackUrl);
     }
     return response;

src/modules/document-caching/constants.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-export const cacheName: string = 'AMP-PUBLISHER-CACHE';
+export const AMP_PUBLISHER_CACHE: string = 'AMP-PUBLISHER-CACHE';

src/modules/document-caching/index.ts

@@ -18,7 +18,7 @@
 import router from 'workbox-routing';
 // @ts-ignore
 import { enable as enableNagigationPreload } from 'workbox-navigation-preload';
-import { cacheName } from './constants';
+import { AMP_PUBLISHER_CACHE } from './constants';
 import AmpDocumentCachablePlugin from './AmpDocumentCachablePlugin';
 import AmpNavigationRoute from './AmpNavigationRoute';
 import { AmpDocumentNetworkFirst } from './AmpDocumentNetworkFirst';
@@ -73,7 +73,7 @@ export class DocumentCachingModule implements AmpSwModule {
     const navRoute = new AmpNavigationRoute(
       new AmpDocumentNetworkFirst(
         {
-          cacheName,
+          cacheName: AMP_PUBLISHER_CACHE,
           plugins: [
             new AmpDocumentCachablePlugin({
               maxEntries: documentCachingOptions.maxDocumentsInCache || 10,
@@ -109,7 +109,7 @@ export class DocumentCachingModule implements AmpSwModule {
           const responseToBeCached = await ampCachablePlugin.cacheWillUpdate({
             response,
           });
-          const cache = await caches.open(cacheName);
+          const cache = await caches.open(AMP_PUBLISHER_CACHE);
           if (responseToBeCached) {
             cache.put(request, responseToBeCached);
           }

src/modules/link-prefetch/constants.ts

@@ -0,0 +1 @@
+export const AMP_PREFETCHED_LINKS: string = 'AMP-PREFETCHED-LINKS';

src/modules/link-prefetch/index.ts

@@ -22,12 +22,12 @@ import { FluxStandardAction } from '../flux-standard-actions';
 import AmpNavigationRoute from '../document-caching/AmpNavigationRoute';
 import { AmpPrefetchPlugin } from './AmpPrefetchPlugin';
 import { AmpSwModule } from '../core/AmpSwModule';
+import { AMP_PREFETCHED_LINKS } from './constants';
 
 export type LinkPrefetchOptions = {
   maxAgeSecondsInCache: Number;
 };
 
-const cacheName = 'AMP-PREFETCHED-LINKS';
 let navigationRoute_: AmpNavigationRoute;
 let linkPrefetchOptions_: LinkPrefetchOptions | undefined;
 
@@ -79,7 +79,7 @@ export class LinkPrefetchAmpModule implements AmpSwModule {
     linkPrefetchOptions_ = linkPrefetchOptions;
     navigationRoute_ = navigationRoute;
     // Read all prefetched links and add it to deny list.
-    const cache = await caches.open(cacheName);
+    const cache = await caches.open(AMP_PREFETCHED_LINKS);
     const linksRegExps: Array<RegExp> = [];
     (await cache.keys()).forEach(request => {
       let url = request.url;
@@ -107,7 +107,7 @@ export class LinkPrefetchAmpModule implements AmpSwModule {
       router.registerRoute(
         link,
         new CacheFirst({
-          cacheName,
+          cacheName: AMP_PREFETCHED_LINKS,
           plugins: [
             new AmpPrefetchPlugin({
               maxEntries: 10,
@@ -134,7 +134,7 @@ export class LinkPrefetchAmpModule implements AmpSwModule {
     });
     // TODO: add logic to only allow URLs within SW scope.
     if (allowedLinks && allowedLinks.length > 0) {
-      const cache = await caches.open(cacheName);
+      const cache = await caches.open(AMP_PREFETCHED_LINKS);
       await cache.addAll(allowedLinks);
       const linkRegExps = allowedLinks.map(link =>
         convertUrlToRegExp(cleanHostInfoFromUrl(link)),

src/modules/offline-page/index.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { cacheName as documentCache } from '../document-caching/constants';
-import { cacheName as assetCache } from '../asset-caching/constants';
+import { AMP_PUBLISHER_CACHE } from '../document-caching/constants';
+import { AMP_ASSET_CACHE } from '../asset-caching/constants';
 import { AmpSwModule } from '../core/AmpSwModule';
 
 export type OfflinePageOptions = {
@@ -25,8 +25,10 @@ export type OfflinePageOptions = {
 
 export class OfflinePageAmpSwModule implements AmpSwModule {
   async init(url: string, assets: Array<string>) {
-    const publisherCache = await caches.open(documentCache);
-    const assetsCache = await caches.open(assetCache);
+    const [publisherCache, assetsCache] = await Promise.all([
+      caches.open(AMP_PUBLISHER_CACHE),
+      caches.open(AMP_ASSET_CACHE),
+    ]);
     const response = await fetch(url);
     if (response.ok) {
       await publisherCache.put(new Request(url), response);

src/modules/service-worker-remover/index.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  VERSIONED_CACHE_NAME,
+  UNVERSIONED_CACHE_NAME,
+} from '../amp-caching/constants';
+import { AMP_ASSET_CACHE } from '../asset-caching/constants';
+import { AMP_PUBLISHER_CACHE } from '../document-caching/constants';
+import { AMP_PREFETCHED_LINKS } from '../link-prefetch/constants';
+
+export class ServiceWorkerRemover {
+  async installNoOpServiceWorker() {
+    // Taking over the document
+    self.addEventListener('install', function(e: ExtendableEvent) {
+      const { skipWaiting } = self as ServiceWorkerGlobalScope;
+      e.waitUntil(skipWaiting());
+    });
+
+    self.addEventListener('activate', async (e: ExtendableEvent) => {
+      const { clients } = self as ServiceWorkerGlobalScope;
+      e.waitUntil(
+        Promise.all([
+          this.cleanCacheStorage(),
+          this.forceRefreshClients(clients),
+        ]),
+      );
+    });
+  }
+
+  async cleanCacheStorage() {
+    return Promise.all([
+      caches.delete(VERSIONED_CACHE_NAME),
+      caches.delete(UNVERSIONED_CACHE_NAME),
+      caches.delete(AMP_ASSET_CACHE),
+      caches.delete(AMP_PUBLISHER_CACHE),
+      caches.delete(AMP_PREFETCHED_LINKS),
+    ]);
+  }
+
+  forceRefreshClients(clients: Clients) {
+    return clients.claim().then(async () => {
+      // Cache current document if its AMP.
+      const windowClients = await clients.matchAll({ type: 'window' });
+      windowClients.forEach((client: WindowClient) =>
+        client.navigate(client.url),
+      );
+    });
+  }
+}

test/amp_metadata.json

@@ -0,0 +1 @@
+{"ampRuntimeVersion":"011905140117570","ampCssUrl":"https://cdn.ampproject.org/rtv/011905140117570/v0.css","canaryPercentage":"0.015","diversions":["001905222334000","031905222334000","021905140117570"]}