Add support for canAddNotesWithDetail with fallback to canAddNotes if not supported

* Add support for canAddNotesWithDetail with fallback if not supported

* Add changes to playwright

<rikaitan.link>MWVlY2YxMWI4M2ZhMzVmMzYyNTZkODYyNDE5ZTUwNTM3MDA3MjllZAo=</rikaitan.link>

Author: jason-ojisan

ext/js/background/backend.js

@@ -625,6 +625,39 @@ export class Backend {
         return newNotes;
     }
 
+    /**
+     * @param {import('anki').Note[]} notes
+     * @param {import('anki').Note[]} notesStrippedNoDuplicates
+     * @returns {Promise<{ note: import('anki').Note, isDuplicate: boolean }[]>}
+     */
+    async _findDuplicates(notes, notesStrippedNoDuplicates) {
+        const canAddNotesWithErrors = await this._anki.canAddNotesWithErrorDetail(notesStrippedNoDuplicates);
+        return canAddNotesWithErrors.map((item, i) => ({
+            note: notes[i],
+            isDuplicate: item.error === null ?
+                false :
+                item.error.includes('cannot create note because it is a duplicate'),
+        }));
+    }
+
+    /**
+     * @param {import('anki').Note[]} notes
+     * @param {import('anki').Note[]} notesStrippedNoDuplicates
+     * @param {import('anki').Note[]} notesStrippedDuplicates
+     * @returns {Promise<{ note: import('anki').Note, isDuplicate: boolean }[]>}
+     */
+    async _findDuplicatesFallback(notes, notesStrippedNoDuplicates, notesStrippedDuplicates) {
+        const [withDuplicatesAllowed, noDuplicatesAllowed] = await Promise.all([
+            this._anki.canAddNotes(notesStrippedDuplicates),
+            this._anki.canAddNotes(notesStrippedNoDuplicates),
+        ]);
+
+        return withDuplicatesAllowed.map((item, i) => ({
+            note: notes[i],
+            isDuplicate: item !== noDuplicatesAllowed[i],
+        }));
+    }
+
     /**
      * @param {import('anki').Note[]} notes
      * @returns {Promise<import('backend').CanAddResults>}
@@ -638,24 +671,16 @@ export class Backend {
         // to check which notes are duplicates.
         const notesNoDuplicatesAllowed = strippedNotes.map((note) => ({...note, options: {...note.options, allowDuplicate: false}}));
 
-        // If only older AnkiConnect available, use `canAddNotes`.
-        const [withDuplicatesAllowed, noDuplicatesAllowed] = await Promise.all([
-            this._anki.canAddNotes(strippedNotes),
-            this._anki.canAddNotes(notesNoDuplicatesAllowed),
-        ]);
-
-        /** @type {{ note: import('anki').Note, isDuplicate: boolean }[]} */
-        const canAddArray = [];
-
-        for (let i = 0; i < withDuplicatesAllowed.length; i++) {
-            if (withDuplicatesAllowed[i] === noDuplicatesAllowed[i]) {
-                canAddArray.push({note: notes[i], isDuplicate: false});
-            } else {
-                canAddArray.push({note: notes[i], isDuplicate: true});
+        try {
+            return await this._findDuplicates(notes, notesNoDuplicatesAllowed);
+        } catch (e) {
+            // User has older anki-connect that does not support canAddNotesWithErrorDetail
+            if (e instanceof ExtensionError && e.message.includes('Anki error: unsupported action')) {
+                return await this._findDuplicatesFallback(notes, notesNoDuplicatesAllowed, strippedNotes);
             }
-        }
 
-        return canAddArray;
+            throw e;
+        }
     }
 
     /** @type {import('api').ApiHandler<'getAnkiNoteInfo'>} */

ext/js/comm/anki-connect.js

@@ -169,6 +169,17 @@ export class AnkiConnect {
         return this._normalizeArray(result, notes.length, 'boolean');
     }
 
+    /**
+     * @param {import('anki').Note[]} notes
+     * @returns {Promise<import('anki').CanAddNotesDetail[]>}
+     */
+    async canAddNotesWithErrorDetail(notes) {
+        if (!this._enabled) { return notes.map(() => ({canAdd: false, error: null})); }
+        await this._checkVersion();
+        const result = await this._invoke('canAddNotesWithErrorDetail', {notes});
+        return this._normalizeCanAddNotesWithErrorDetailArray(result, notes.length);
+    }
+
     /**
      * @param {import('anki').NoteId[]} noteIds
      * @returns {Promise<(?import('anki').NoteInfo)[]>}
@@ -725,4 +736,40 @@ export class AnkiConnect {
         }
         return result2;
     }
+
+    /**
+     * @param {unknown} result
+     * @param {number} expectedCount
+     * @returns {import('anki').CanAddNotesDetail[]}
+     * @throws {Error}
+     */
+    _normalizeCanAddNotesWithErrorDetailArray(result, expectedCount) {
+        if (!Array.isArray(result)) {
+            throw this._createUnexpectedResultError('array', result, '');
+        }
+        if (expectedCount !== result.length) {
+            throw this._createError(`Unexpected result array size: expected ${expectedCount}, received ${result.length}`, result);
+        }
+        /** @type {import('anki').CanAddNotesDetail[]} */
+        const result2 = [];
+        for (let i = 0; i < expectedCount; ++i) {
+            const item = /** @type {unknown} */ (result[i]);
+            if (item === null || typeof item !== 'object') {
+                throw this._createError(`Unexpected result type at index ${i}: expected object, received ${this._getTypeName(item)}`, result);
+            }
+
+            const {canAdd, error} = /** @type {{[key: string]: unknown}} */ (item);
+            if (typeof canAdd !== 'boolean') {
+                throw this._createError(`Unexpected result type at index ${i}, field canAdd: expected boolean, received ${this._getTypeName(canAdd)}`, result);
+            }
+
+            const item2 = {
+                canAdd: canAdd,
+                error: typeof error === 'string' ? error : null,
+            };
+
+            result2.push(item2);
+        }
+        return result2;
+    }
 }

test/playwright/playwright-util.js

@@ -139,6 +139,7 @@ function getResponseBody(action) {
         case 'modelNames': return ['Mock Model'];
         case 'modelFieldNames': return [...getMockModelFields().keys()];
         case 'canAddNotes': return [true, true];
+        case 'canAddNotesWithErrorDetail': return [{canAdd: true}, {canAdd: true}];
         case 'storeMediaFile': return 'mock_audio.mp3';
         case 'addNote': return 102312488912;
         case 'multi': return [];

types/ext/anki.d.ts

@@ -83,3 +83,8 @@ export type MessageBody = {
     version: number;
     key?: string;
 };
+
+export type CanAddNotesDetail = {
+    canAdd: boolean;
+    error: string | null;
+};