cozy-search 2.4.0 → 2.5.0

package/README.md

@@ -61,12 +61,19 @@ of verbs (cozy-home and cozy-drive use `ALL`).
 
 Opening the assistant (`AssistantView` or `AssistantDialog`) calls
 `autoprovisionAssistants(client)` once per session: when the
-`cozy.assistant.autoprovision` flag lists assistants, it runs
-`setupRagIndexing(client)` then `ensureProvisionedAssistants(client, entries)`.
-A host app that wants this done at startup, before the assistant is
-opened, can call `autoprovisionAssistants(client)` itself (or the
-`useAssistantsAutoprovision` hook): every call shares the first one's
-promise, so the two never race.
+`cozy.assistant.autoprovision` flag lists assistants, it makes sure the
+`rag-index` triggers exist, gives the root folder to the assistants that
+have no knowledge base folder, then runs
+`ensureProvisionedAssistants(client, entries)`.
+
+A host app should only call the `useRagIndexTriggers` hook (or
+`ensureRagIndexTriggers(client)`) at startup: one request when the
+triggers already exist, and the knowledge base folders get indexed as
+they change before the assistant is ever opened. The assistants are
+provisioned when the assistant opens; a host app that wants that earlier
+can call `autoprovisionAssistants(client)` or the
+`useAssistantsAutoprovision` hook. Every call shares the first one's
+promise, the triggers step included, so nothing runs twice.
 
 `setupRagIndexing(client)` makes sure the instance's two
 `rag-index` triggers exist (one on `io.cozy.files`, one on

package/dist/components/KnowledgeBase/autoprovision.d.ts

@@ -1,4 +1,9 @@
 export function resetAutoprovisionForTests(): void;
+export function autoprovisionEntries(): Array<object> | null;
+export function ensureRagIndexTriggers(client: import("cozy-client").CozyClient): Promise<{
+    triggers: string[];
+    error: Error | null;
+}>;
 export function autoprovisionAssistants(client: import("cozy-client").CozyClient): Promise<null | {
     setup: object;
     created: string[];

package/dist/components/KnowledgeBase/autoprovision.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.resetAutoprovisionForTests = exports.autoprovisionAssistants = void 0;
+exports.resetAutoprovisionForTests = exports.ensureRagIndexTriggers = exports.autoprovisionEntries = exports.autoprovisionAssistants = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -34,24 +34,70 @@ var warn = function warn() {
   (_console = console).warn.apply(_console, ['cozy-search autoprovision:'].concat(args));
 };
 
+var triggersPending = null;
 var pending = null;
 
 var resetAutoprovisionForTests = function resetAutoprovisionForTests() {
+  triggersPending = null;
   pending = null;
 };
+/**
+ * The entries of the autoprovision flag, or null when it lists nothing.
+ * @returns {Array<object>|null}
+ */
+
 
 exports.resetAutoprovisionForTests = resetAutoprovisionForTests;
 
+var autoprovisionEntries = function autoprovisionEntries() {
+  var entries = (0, _cozyFlags.default)(_provisioning.AUTOPROVISION_FLAG);
+  return Array.isArray(entries) && entries.length > 0 ? entries : null;
+};
+/**
+ * Makes sure the instance has its rag-index triggers, so the files of the
+ * knowledge base folders get indexed as they change. Runs once per session
+ * and never rejects: a host app can call it at startup, it costs a single
+ * request when the triggers already exist.
+ * @param {import('cozy-client').CozyClient} client - The cozy client.
+ * @returns {Promise<{triggers: string[], error: Error|null}>} The
+ * `arguments` of the triggers created, and the failure if any.
+ */
+
+
+exports.autoprovisionEntries = autoprovisionEntries;
+
+var ensureRagIndexTriggers = function ensureRagIndexTriggers(client) {
+  if (!triggersPending) {
+    triggersPending = (0, _ragIndexing.createRagIndexTriggers)(client).then(function (triggers) {
+      return {
+        triggers: triggers,
+        error: null
+      };
+    }, function (error) {
+      warn('cannot set up the rag-index triggers', error);
+      return {
+        triggers: [],
+        error: error
+      };
+    });
+  }
+
+  return triggersPending;
+};
+
+exports.ensureRagIndexTriggers = ensureRagIndexTriggers;
+
 var run = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client) {
-    var entries, setup, result;
+    var entries, setup, _yield$ensureRagIndex, triggers, error, assistants, result;
+
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            entries = (0, _cozyFlags.default)(_provisioning.AUTOPROVISION_FLAG);
+            entries = autoprovisionEntries();
 
-            if (!(!Array.isArray(entries) || entries.length === 0)) {
+            if (entries) {
               _context.next = 3;
               break;
             }
@@ -59,15 +105,48 @@ var run = /*#__PURE__*/function () {
             return _context.abrupt("return", null);
 
           case 3:
-            _context.next = 5;
-            return (0, _ragIndexing.setupRagIndexing)(client);
-
-          case 5:
-            setup = _context.sent;
-            _context.next = 8;
-            return (0, _provisioning.ensureProvisionedAssistants)(client, entries);
-
-          case 8:
+            setup = {
+              triggers: [],
+              migrated: [],
+              errors: []
+            };
+            _context.next = 6;
+            return ensureRagIndexTriggers(client);
+
+          case 6:
+            _yield$ensureRagIndex = _context.sent;
+            triggers = _yield$ensureRagIndex.triggers;
+            error = _yield$ensureRagIndex.error;
+            setup.triggers = triggers;
+            if (error) setup.errors.push(error);
+            assistants = null;
+            _context.prev = 12;
+            _context.next = 15;
+            return (0, _ragIndexing.fetchAssistants)(client);
+
+          case 15:
+            assistants = _context.sent;
+            _context.next = 18;
+            return (0, _ragIndexing.migrateAssistantsWithoutFolder)(client, assistants);
+
+          case 18:
+            setup.migrated = _context.sent;
+            _context.next = 25;
+            break;
+
+          case 21:
+            _context.prev = 21;
+            _context.t0 = _context["catch"](12);
+            warn('cannot migrate the assistants without folder', _context.t0);
+            setup.errors.push(_context.t0);
+
+          case 25:
+            _context.next = 27;
+            return (0, _provisioning.ensureProvisionedAssistants)(client, entries, {
+              assistants: assistants
+            });
+
+          case 27:
             result = _context.sent;
 
             if (result.skipped.length > 0) {
@@ -78,12 +157,12 @@ var run = /*#__PURE__*/function () {
               setup: setup
             }, result));
 
-          case 11:
+          case 30:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee);
+    }, _callee, null, [[12, 21]]);
   }));
 
   return function run(_x) {
@@ -91,10 +170,12 @@ var run = /*#__PURE__*/function () {
   };
 }();
 /**
- * Sets up the rag-index triggers, then provisions the assistants listed in
- * the autoprovision flag. Runs once per session: every call shares the
- * first one's promise, so the assistant UI and the host app's startup can
- * both trigger it without racing each other. Never rejects.
+ * Sets up the rag-index triggers, gives a folder to the assistants that
+ * lack one, then provisions the assistants listed in the autoprovision
+ * flag. Runs once per session: every call shares the first one's promise,
+ * and the triggers step is shared with ensureRagIndexTriggers, so a host
+ * app that ensured them at startup does not pay for them twice. Never
+ * rejects.
  * @param {import('cozy-client').CozyClient} client - The cozy client.
  * @returns {Promise<null|{setup: object, created: string[], ensured: string[], skipped: {id: string, reason: string}[]}>} Null when the flag lists nothing.
  */

package/dist/components/KnowledgeBase/autoprovision.spec.js

@@ -2,59 +2,135 @@ import flag from 'cozy-flags'
 
 import {
   autoprovisionAssistants,
+  autoprovisionEntries,
+  ensureRagIndexTriggers,
   resetAutoprovisionForTests
 } from './autoprovision'
 import { ensureProvisionedAssistants } from './provisioning'
-import { setupRagIndexing } from './ragIndexing'
+import {
+  createRagIndexTriggers,
+  fetchAssistants,
+  migrateAssistantsWithoutFolder
+} from './ragIndexing'
 
 jest.mock('cozy-flags', () => jest.fn())
 jest.mock('./provisioning', () => ({
   AUTOPROVISION_FLAG: 'cozy.assistant.autoprovision',
   ensureProvisionedAssistants: jest.fn()
 }))
-jest.mock('./ragIndexing', () => ({ setupRagIndexing: jest.fn() }))
+jest.mock('./ragIndexing', () => ({
+  createRagIndexTriggers: jest.fn(),
+  fetchAssistants: jest.fn(),
+  migrateAssistantsWithoutFolder: jest.fn()
+}))
 
 const client = { id: 'client' }
 const entries = [{ name: 'Docs', dirName: 'Docs' }]
+const assistants = [{ _id: 'legacy' }]
 let warnSpy
 
-describe('autoprovisionAssistants', () => {
-  beforeEach(() => {
-    resetAutoprovisionForTests()
-    flag.mockReset()
-
-    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-    setupRagIndexing
-      .mockReset()
-      .mockResolvedValue({ triggers: [], migrated: [], errors: [] })
-    ensureProvisionedAssistants
-      .mockReset()
-      .mockResolvedValue({ created: ['docs'], ensured: [], skipped: [] })
+beforeEach(() => {
+  resetAutoprovisionForTests()
+  flag.mockReset()
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  createRagIndexTriggers.mockReset().mockResolvedValue(['io.cozy.files'])
+  fetchAssistants.mockReset().mockResolvedValue(assistants)
+  migrateAssistantsWithoutFolder.mockReset().mockResolvedValue([])
+  ensureProvisionedAssistants
+    .mockReset()
+    .mockResolvedValue({ created: ['docs'], ensured: [], skipped: [] })
+})
+
+afterEach(() => {
+  warnSpy.mockRestore()
+})
+
+describe('autoprovisionEntries', () => {
+  it('returns the flag entries', () => {
+    flag.mockReturnValue(entries)
+    expect(autoprovisionEntries()).toBe(entries)
+    expect(flag).toHaveBeenCalledWith('cozy.assistant.autoprovision')
+  })
+
+  it.each([null, undefined, [], 'docs', {}])('returns null for %p', value => {
+    flag.mockReturnValue(value)
+    expect(autoprovisionEntries()).toBeNull()
   })
+})
 
-  afterEach(() => {
-    warnSpy.mockRestore()
+describe('ensureRagIndexTriggers', () => {
+  it('creates the missing triggers once per session', async () => {
+    const first = ensureRagIndexTriggers(client)
+    expect(ensureRagIndexTriggers(client)).toBe(first)
+    await expect(first).resolves.toEqual({
+      triggers: ['io.cozy.files'],
+      error: null
+    })
+    await ensureRagIndexTriggers(client)
+
+    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
+    expect(createRagIndexTriggers).toHaveBeenCalledWith(client)
   })
 
+  it('reports a failure without rejecting', async () => {
+    const error = new Error('forbidden')
+    createRagIndexTriggers.mockRejectedValue(error)
+    await expect(ensureRagIndexTriggers(client)).resolves.toEqual({
+      triggers: [],
+      error
+    })
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'cannot set up the rag-index triggers',
+      error
+    )
+  })
+})
+
+describe('autoprovisionAssistants', () => {
   it('does nothing without flag entries', async () => {
     flag.mockReturnValue(null)
     await expect(autoprovisionAssistants(client)).resolves.toBeNull()
-    expect(flag).toHaveBeenCalledWith('cozy.assistant.autoprovision')
-    expect(setupRagIndexing).not.toHaveBeenCalled()
+    expect(createRagIndexTriggers).not.toHaveBeenCalled()
+    expect(fetchAssistants).not.toHaveBeenCalled()
+    expect(migrateAssistantsWithoutFolder).not.toHaveBeenCalled()
     expect(ensureProvisionedAssistants).not.toHaveBeenCalled()
   })
 
-  it('sets up the indexing, then provisions the flag entries', async () => {
+  it('lets the provisioning query the assistants when listing them failed', async () => {
+    flag.mockReturnValue(entries)
+    fetchAssistants.mockRejectedValue(new Error('nope'))
+    const result = await autoprovisionAssistants(client)
+
+    expect(migrateAssistantsWithoutFolder).not.toHaveBeenCalled()
+    expect(ensureProvisionedAssistants).toHaveBeenCalledWith(client, entries, {
+      assistants: null
+    })
+    expect(result.setup.errors.map(e => e.message)).toEqual(['nope'])
+  })
+
+  it('ensures the triggers, migrates, then provisions the flag entries', async () => {
     flag.mockReturnValue(entries)
+    migrateAssistantsWithoutFolder.mockResolvedValue(['legacy'])
     const result = await autoprovisionAssistants(client)
 
-    expect(setupRagIndexing).toHaveBeenCalledWith(client)
-    expect(ensureProvisionedAssistants).toHaveBeenCalledWith(client, entries)
-    expect(setupRagIndexing.mock.invocationCallOrder[0]).toBeLessThan(
-      ensureProvisionedAssistants.mock.invocationCallOrder[0]
+    expect(createRagIndexTriggers).toHaveBeenCalledWith(client)
+    expect(fetchAssistants).toHaveBeenCalledTimes(1)
+    expect(migrateAssistantsWithoutFolder).toHaveBeenCalledWith(
+      client,
+      assistants
     )
+    expect(ensureProvisionedAssistants).toHaveBeenCalledWith(client, entries, {
+      assistants
+    })
+    const order = [
+      createRagIndexTriggers,
+      migrateAssistantsWithoutFolder,
+      ensureProvisionedAssistants
+    ].map(fn => fn.mock.invocationCallOrder[0])
+    expect(order).toEqual([...order].sort((a, b) => a - b))
     expect(result).toEqual({
-      setup: { triggers: [], migrated: [], errors: [] },
+      setup: { triggers: ['io.cozy.files'], migrated: ['legacy'], errors: [] },
       created: ['docs'],
       ensured: [],
       skipped: []
@@ -64,26 +140,34 @@ describe('autoprovisionAssistants', () => {
   it('runs once per session, sharing the promise', async () => {
     flag.mockReturnValue(entries)
     const first = autoprovisionAssistants(client)
-    const second = autoprovisionAssistants(client)
-    expect(second).toBe(first)
+    expect(autoprovisionAssistants(client)).toBe(first)
     await first
     await autoprovisionAssistants(client)
 
-    expect(setupRagIndexing).toHaveBeenCalledTimes(1)
+    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
     expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
   })
 
-  it('still provisions when the setup reported errors', async () => {
+  it('shares the triggers step with ensureRagIndexTriggers', async () => {
     flag.mockReturnValue(entries)
-    setupRagIndexing.mockResolvedValue({
-      triggers: [],
-      migrated: [],
-      errors: [new Error('forbidden')]
-    })
+    await ensureRagIndexTriggers(client)
+    await autoprovisionAssistants(client)
+
+    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+  })
+
+  it('still provisions when the setup steps failed', async () => {
+    flag.mockReturnValue(entries)
+    createRagIndexTriggers.mockRejectedValue(new Error('forbidden'))
+    migrateAssistantsWithoutFolder.mockRejectedValue(new Error('nope'))
     const result = await autoprovisionAssistants(client)
 
     expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
-    expect(result.setup.errors).toHaveLength(1)
+    expect(result.setup.errors.map(e => e.message)).toEqual([
+      'forbidden',
+      'nope'
+    ])
   })
 
   it('logs the skipped entries', async () => {
@@ -104,7 +188,7 @@ describe('autoprovisionAssistants', () => {
 
   it('never rejects', async () => {
     flag.mockReturnValue(entries)
-    setupRagIndexing.mockRejectedValue(new Error('boom'))
+    ensureProvisionedAssistants.mockRejectedValue(new Error('boom'))
     await expect(autoprovisionAssistants(client)).resolves.toBeNull()
     expect(warnSpy).toHaveBeenCalledWith(
       'cozy-search autoprovision:',

package/dist/components/KnowledgeBase/provisioning.d.ts

@@ -14,7 +14,9 @@ export function ensureProvisionedAssistants(client: import("cozy-client").CozyCl
     prompt?: string;
     icon?: string | null;
     default?: boolean;
-}>): Promise<{
+}>, { assistants }?: {
+    assistants?: object[] | undefined;
+} | undefined): Promise<{
     created: string[];
     ensured: string[];
     skipped: {