merge with master

Author: ameshkov

.gitignore

@@ -1,9 +1,14 @@
+.DS_Store
 node_modules
 .nyc_output
-.DS_Store
 *.log
-.vscode
-.idea
 .awcache
 .rpt2_cache
+.nx
+
+# IDEA files
+.idea
+
+# VS code settings and workspace project
+.vscode
 tsurlfilter.code-workspace

packages/adguard-api/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.2] - 2024-02-08
+
+### Added
+- New private method `removeObsoletedFilters` to prevent usage of obsoleted filters.
+- New public event channel `AdguardApi.onFiltersDeletion`.
+
+### Changed
+- `adguardApi.start` returns Promise with applied configuration with already removed
+obsoleted filters ids.
+
 ## [2.1.1] - 2023-12-01
 
 ### Added

packages/adguard-api/README.md

@@ -195,12 +195,12 @@ const handleAppMessage = async (message: Message) => {
 };
 
 // route message depending on handler name
-browser.runtime.onMessage.addListener(async (message, sender) => { 
+browser.runtime.onMessage.addListener(async (message, sender) => {
   if (message?.handlerName === MESSAGE_HANDLER_NAME) {
     return Promise.resolve(handleApiMessage(message, sender));
   }
   return handleAppMessage(message);
-});    
+});
 ```
 
 **Returns:**
@@ -405,6 +405,36 @@ adguardApi.onAssistantCreateRule.subscribe(applyRule);
 adguardApi.onAssistantCreateRule.unsubscribe(applyRule);
 ```
 
+### `adguardApi.onFiltersDeletion`
+
+TsWebExtension Event channel, which fires event on obsoleted filters deletion.
+It can be fired after checking an update for filters in the FiltersUpdateService.
+
+**Syntax:**
+
+```typescript
+public onFiltersDeletion: EventChannel<number[]>;
+```
+
+**Example:**
+
+```typescript
+
+// update config on filter deletion
+const removeObsoletedFilterId = async (filterIds: number[]): Promise<void> => {
+  console.log(`Filters with ids ${filterIds} deleted because they became obsoleted.`);
+  configuration.filters = configuration.filters.filter((id) => !filterIds.includes(id));
+
+  await adguardApi.configure(configuration);
+};
+
+// add listener
+adguardApi.onFiltersDeletion.subscribe(removeObsoletedFilterId);
+
+// remove listener
+adguardApi.onFiltersDeletion.unsubscribe(removeObsoletedFilterId);
+```
+
 ### `adguardApi.onRequestBlocking`
 
 API for adding and removing listeners for request blocking events.

packages/adguard-api/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@adguard/api",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "This is a TypeScript library that implements AdGuard's extension API",
   "main": "dist/adguard-api.js",
-  "files": ["dist/**/*"],
+  "files": [
+    "dist/**/*"
+  ],
   "typings": "dist/types/background/index.d.ts",
   "exports": {
     ".": "./dist/adguard-api.js",

packages/adguard-api/src/background/filters/api.ts

@@ -53,11 +53,17 @@ export class FiltersApi {
     }
 
     /**
-     * Initializes linked APIs
+     * Initializes linked APIs.
+     *
+     * @param filterIds IDs of filters to check for possible obsoleting.
+     *
+     * @returns List of outdated filters ids.
      */
-    public async init(): Promise<void> {
+    public async init(filterIds: number[]): Promise<number[]> {
         await this.metadataApi.init();
         await this.versionsApi.init();
+
+        return this.removeObsoleteFilters(filterIds);
     }
 
     /**
@@ -113,16 +119,21 @@ export class FiltersApi {
      * If filter version in metadata is higher, downloads and saves new rules content
      *
      * Dispatches {@link NotifierEventType.UpdateFilters} event, if at least one filter has been updated
+     *
+     * @returns List of outdated filters ids.
      */
-    public async updateFilters(): Promise<void> {
+    public async updateFilters(): Promise<number[]> {
         this.logger.info("Update filters");
         /**
          * Reload filters metadata from backend for correct
          * version matching on update check.
          */
         await this.metadataApi.loadMetadata();
 
-        const ids = this.versionsApi.getInstalledFilters();
+        const installedFilterIds = this.versionsApi.getInstalledFilters();
+        const obsoletedFiltersIds = await this.removeObsoleteFilters(installedFilterIds);
+
+        const ids = installedFilterIds.filter((id) => !obsoletedFiltersIds.includes(id));
 
         const updateTasks = ids.map(async (id) => this.updateFilter(id));
 
@@ -131,6 +142,47 @@ export class FiltersApi {
         if (updatedFilters.some((filterData) => !!filterData?.filterId)) {
             notifier.publishEvent({ type: NotifierEventType.UpdateFilters });
         }
+
+        return obsoletedFiltersIds;
+    }
+
+    /**
+     * Remove if necessary obsolete filters.
+     *
+     * @param filterIds IDs of filters to check for possible obsoleting.
+     *
+     * @returns List of outdated filters ids.
+     */
+    private async removeObsoleteFilters(filterIds: number[]): Promise<number[]> {
+        const installedFilterIds = this.versionsApi.getInstalledFilters();
+        const metadataFiltersIds = this.metadataApi.getFiltersMetadata().map(({ filterId }) => filterId);
+
+        const obsoletedFiltersIds = filterIds.filter((id) => !metadataFiltersIds.includes(id));
+
+        const tasks = obsoletedFiltersIds.map(async (id) => {
+            if (installedFilterIds.includes(id)) {
+                await this.versionsApi.delete(id);
+                await this.filterRulesApi.remove(id);
+
+                this.logger.info(`Obsoleted filter with id: ${id} removed from the storage`);
+            }
+        });
+
+        const promises = await Promise.allSettled(tasks);
+        // Handles errors
+        promises.forEach((promise) => {
+            if (promise.status === "rejected") {
+                this.logger.error("Cannot remove obsoleted filter from storage due to: ", promise.reason);
+            }
+        });
+
+        // Notify top-level about deletion of obsoleted filters.
+        notifier.publishEvent({
+            type: NotifierEventType.DeleteFilters,
+            data: { filtersIds: obsoletedFiltersIds },
+        });
+
+        return obsoletedFiltersIds;
     }
 
     /**

packages/adguard-api/src/background/filters/rules.ts

@@ -49,6 +49,15 @@ export class FilterRulesApi {
         await this.storage.set(FilterRulesApi.getFilterKey(filterId), rules);
     }
 
+    /**
+     * Removes specified filter list from {@link storage}.
+     *
+     * @param filterId Filter id.
+     */
+    async remove(filterId: number): Promise<void> {
+        await this.storage.remove(FilterRulesApi.getFilterKey(filterId));
+    }
+
     /**
      * Generates {@link Storage} key for specified filter rules
      *

packages/adguard-api/src/background/filters/versions.ts

@@ -109,6 +109,22 @@ export class VersionsApi {
         await this.saveData();
     }
 
+    /**
+     * Deletes specified filter version.
+     *
+     * @param filterId Filter id.
+     * @throws Error if filter version data is not initialized.
+     */
+    public async delete(filterId: number): Promise<void> {
+        if (!this.versions) {
+            throw new Error("Filter versions are not initialized");
+        }
+
+        delete this.versions[filterId];
+
+        await this.saveData();
+    }
+
     /**
      * Save data in extension storage
      */

packages/adguard-api/src/background/main.ts

@@ -19,16 +19,16 @@
 import {
     type TsWebExtension,
     type ConfigurationMV2 as TsWebExtensionConfiguration,
-    type EventChannel,
     type MessageHandlerMV2,
+    EventChannel,
     createTsWebExtension,
 } from "@adguard/tswebextension";
 
 import { Network } from "./network";
 import { Storage } from "./storage";
 import { FiltersApi, FiltersUpdateService, LocaleDetectService } from "./filters";
 import { Configuration, configurationValidator } from "./schemas";
-import { DetectFiltersEvent, notifier, NotifierEventType } from "./notifier";
+import { DeleteFiltersEvent, DetectFiltersEvent, notifier, NotifierEventType } from "./notifier";
 import { RequestBlockingLogger } from "./request-blocking-logger";
 import { Logger } from "./logger";
 
@@ -79,6 +79,11 @@ export class AdguardApi {
      */
     public onAssistantCreateRule: EventChannel<string>;
 
+    /**
+     * {@link TsWebExtension} {@link EventChannel}, which fires event on obsoleted filters deletion.
+     */
+    public onFiltersDeletion: EventChannel<number[]>;
+
     /**
      * API for adding and removing listeners for request blocking events.
      *
@@ -91,6 +96,8 @@ export class AdguardApi {
 
         this.onAssistantCreateRule = this.tswebextension.onAssistantCreateRule;
 
+        this.onFiltersDeletion = new EventChannel<number[]>();
+
         this.network = new Network();
 
         const storage = new Storage();
@@ -106,6 +113,7 @@ export class AdguardApi {
         this.openAssistant = this.openAssistant.bind(this);
         this.handleDetectFilters = this.handleDetectFilters.bind(this);
         this.handleUpdateFilters = this.handleUpdateFilters.bind(this);
+        this.handleDeleteFilters = this.handleDeleteFilters.bind(this);
     }
 
     /**
@@ -121,25 +129,28 @@ export class AdguardApi {
      * Initializes AdGuard with specified {@link Configuration} and starts it immediately.
      *
      * @param configuration - api {@link Configuration}
-     * @returns applied {@link Configuration} promise
+     *
+     * @returns applied {@link Configuration} promise.
      */
     public async start(configuration: Configuration): Promise<Configuration> {
         this.configuration = configurationValidator.parse(configuration);
 
         this.network.configure(this.configuration);
 
-        await this.filtersApi.init();
+        const obsoletedFiltersIds = await this.filtersApi.init(configuration.filters);
+        this.configuration.filters = this.configuration.filters.filter((id) => !obsoletedFiltersIds.includes(id));
         this.filtersUpdateService.start();
         this.localeDetectService.start();
 
         notifier.addListener(NotifierEventType.UpdateFilters, this.handleUpdateFilters);
         notifier.addListener(NotifierEventType.DetectFilters, this.handleDetectFilters);
+        notifier.addListener(NotifierEventType.DeleteFilters, this.handleDeleteFilters);
 
         const tsWebExtensionConfiguration = await this.createTsWebExtensionConfiguration();
 
         await this.tswebextension.start(tsWebExtensionConfiguration);
 
-        return configuration;
+        return this.configuration;
     }
 
     /**
@@ -155,7 +166,8 @@ export class AdguardApi {
      * Modifies AdGuard {@link Configuration}. Please note, that Adguard must be already started.
      *
      * @param configuration - api {@link Configuration}
-     * @returns applied {@link Configuration} promise
+     *
+     * @returns applied {@link Configuration} promise.
      */
     public async configure(configuration: Configuration): Promise<Configuration> {
         this.configuration = configurationValidator.parse(configuration);
@@ -166,7 +178,7 @@ export class AdguardApi {
 
         await this.tswebextension.configure(tsWebExtensionConfiguration);
 
-        return configuration;
+        return this.configuration;
     }
 
     /**
@@ -271,6 +283,23 @@ export class AdguardApi {
         this.logger.info("Reload engine with updated filter ids list");
     }
 
+    /**
+     * Handles fired {@link DeleteFiltersEvent}
+     *
+     * @param event - fired {@link DeleteFiltersEvent}
+     */
+    private async handleDeleteFilters(event: DeleteFiltersEvent): Promise<void> {
+        const deletedFiltersIds = event.data.filtersIds;
+
+        if (deletedFiltersIds.length === 0) {
+            return;
+        }
+
+        this.onFiltersDeletion.dispatch(deletedFiltersIds);
+
+        this.logger.info(`Filters with ids ${deletedFiltersIds} has been removed.`);
+    }
+
     /**
      * Handles fired {@link DetectFiltersEvent}
      *

packages/adguard-api/src/background/notifier.ts

@@ -19,6 +19,7 @@
 export enum NotifierEventType {
     DetectFilters = "DetectFilters",
     UpdateFilters = "UpdateFilters",
+    DeleteFilters = "DeleteFilters",
 }
 
 export type DetectFiltersEvent = {
@@ -32,7 +33,14 @@ export type UpdateFiltersEvent = {
     type: NotifierEventType.UpdateFilters;
 };
 
-export type NotifierEvent = DetectFiltersEvent | UpdateFiltersEvent;
+export type DeleteFiltersEvent = {
+    type: NotifierEventType.DeleteFilters;
+    data: {
+        filtersIds: number[];
+    };
+};
+
+export type NotifierEvent = DetectFiltersEvent | UpdateFiltersEvent | DeleteFiltersEvent;
 
 export type ExtractedNotifierEvent<T> = Extract<NotifierEvent, { type: T }>;
 
@@ -50,6 +58,7 @@ export class Notifier {
     private listenersMap: NotifierListenersMap = {
         [NotifierEventType.DetectFilters]: [],
         [NotifierEventType.UpdateFilters]: [],
+        [NotifierEventType.DeleteFilters]: [],
     };
 
     /**
@@ -79,7 +88,7 @@ export class Notifier {
      *
      * @param event - event data
      */
-    public publishEvent<T extends DetectFiltersEvent | UpdateFiltersEvent>(event: T): void {
+    public publishEvent<T extends NotifierEvent>(event: T): void {
         const listeners = this.listenersMap[event.type] as NotifierListener<NotifierEventType>[];
 
         listeners.forEach((listener) => {