cozy-search 2.3.3 → 2.4.0

package/README.md

@@ -59,9 +59,16 @@ of verbs (cozy-home and cozy-drive use `ALL`).
 
 ### RAG indexing setup
 
-Call `setupRagIndexing(client)` once per session at startup (before
-`ensureProvisionedAssistants` if your app provisions assistants from the
-`rag.assistants.autoprovision` flag). It makes sure the instance's two
+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.
+
+`setupRagIndexing(client)` makes sure the instance's two
 `rag-index` triggers exist (one on `io.cozy.files`, one on
 `io.cozy.ai.chat.assistants`) and gives the root folder to any assistant
 that has no knowledge base folder yet — the stack's `rag-index` worker
@@ -76,7 +83,7 @@ never throws: on a stack whose `rag-index` worker is still reserved, the
 additionally creates one `io.cozy.accounts` document per provisioned
 assistant, and the `dirName` folder in `io.cozy.files`.
 
-An entry of `rag.assistants.autoprovision` can carry `"default": true`
+An entry of `cozy.assistant.autoprovision` can carry `"default": true`
 (the first flagged entry wins if there are several). Every NEW
 conversation then starts on that assistant once its document exists —
 from the session after it was provisioned onward. Existing conversations

package/dist/components/Assistant/AssistantContainer.js

@@ -21,6 +21,8 @@ var _Conversation = _interopRequireDefault(require("../Conversations/Conversatio
 
 var _CozyAssistantRuntimeProvider = _interopRequireDefault(require("../CozyAssistantRuntimeProvider"));
 
+var _useAssistantsAutoprovision = require("../KnowledgeBase/useAssistantsAutoprovision");
+
 var _SearchConversation = _interopRequireDefault(require("../Search/SearchConversation"));
 
 var _Sidebar = _interopRequireDefault(require("../Sidebar"));
@@ -43,6 +45,7 @@ var AssistantContainer = function AssistantContainer() {
   var _useAssistant = (0, _AssistantProvider.useAssistant)(),
       isOpenSearchConversation = _useAssistant.isOpenSearchConversation;
 
+  (0, _useAssistantsAutoprovision.useAssistantsAutoprovision)();
   return /*#__PURE__*/_react.default.createElement("div", {
     className: (0, _classnames.default)('u-flex u-ov-hidden u-h-100', styles['assistant-container'])
   }, /*#__PURE__*/_react.default.createElement(_Sidebar.default, {

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

@@ -0,0 +1,10 @@
+export function resetAutoprovisionForTests(): void;
+export function autoprovisionAssistants(client: import("cozy-client").CozyClient): Promise<null | {
+    setup: object;
+    created: string[];
+    ensured: string[];
+    skipped: {
+        id: string;
+        reason: string;
+    }[];
+}>;

package/dist/components/KnowledgeBase/autoprovision.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetAutoprovisionForTests = exports.autoprovisionAssistants = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _cozyFlags = _interopRequireDefault(require("cozy-flags"));
+
+var _provisioning = require("./provisioning");
+
+var _ragIndexing = require("./ragIndexing");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var warn = function warn() {
+  var _console;
+
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  // eslint-disable-next-line no-console
+  (_console = console).warn.apply(_console, ['cozy-search autoprovision:'].concat(args));
+};
+
+var pending = null;
+
+var resetAutoprovisionForTests = function resetAutoprovisionForTests() {
+  pending = null;
+};
+
+exports.resetAutoprovisionForTests = resetAutoprovisionForTests;
+
+var run = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client) {
+    var entries, setup, result;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            entries = (0, _cozyFlags.default)(_provisioning.AUTOPROVISION_FLAG);
+
+            if (!(!Array.isArray(entries) || entries.length === 0)) {
+              _context.next = 3;
+              break;
+            }
+
+            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:
+            result = _context.sent;
+
+            if (result.skipped.length > 0) {
+              warn('skipped entries', result.skipped);
+            }
+
+            return _context.abrupt("return", _objectSpread({
+              setup: setup
+            }, result));
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function run(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * 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.
+ * @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.
+ */
+
+
+var autoprovisionAssistants = function autoprovisionAssistants(client) {
+  if (!pending) {
+    pending = run(client).catch(function (error) {
+      warn('failed', error);
+      return null;
+    });
+  }
+
+  return pending;
+};
+
+exports.autoprovisionAssistants = autoprovisionAssistants;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,115 @@
+import flag from 'cozy-flags'
+
+import {
+  autoprovisionAssistants,
+  resetAutoprovisionForTests
+} from './autoprovision'
+import { ensureProvisionedAssistants } from './provisioning'
+import { setupRagIndexing } 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() }))
+
+const client = { id: 'client' }
+const entries = [{ name: 'Docs', dirName: 'Docs' }]
+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: [] })
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+  })
+
+  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(ensureProvisionedAssistants).not.toHaveBeenCalled()
+  })
+
+  it('sets up the indexing, then provisions the flag entries', async () => {
+    flag.mockReturnValue(entries)
+    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(result).toEqual({
+      setup: { triggers: [], migrated: [], errors: [] },
+      created: ['docs'],
+      ensured: [],
+      skipped: []
+    })
+  })
+
+  it('runs once per session, sharing the promise', async () => {
+    flag.mockReturnValue(entries)
+    const first = autoprovisionAssistants(client)
+    const second = autoprovisionAssistants(client)
+    expect(second).toBe(first)
+    await first
+    await autoprovisionAssistants(client)
+
+    expect(setupRagIndexing).toHaveBeenCalledTimes(1)
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+  })
+
+  it('still provisions when the setup reported errors', async () => {
+    flag.mockReturnValue(entries)
+    setupRagIndexing.mockResolvedValue({
+      triggers: [],
+      migrated: [],
+      errors: [new Error('forbidden')]
+    })
+    const result = await autoprovisionAssistants(client)
+
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+    expect(result.setup.errors).toHaveLength(1)
+  })
+
+  it('logs the skipped entries', async () => {
+    flag.mockReturnValue(entries)
+    ensureProvisionedAssistants.mockResolvedValue({
+      created: [],
+      ensured: [],
+      skipped: [{ id: 'docs', reason: 'nope' }]
+    })
+    await autoprovisionAssistants(client)
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'skipped entries',
+      [{ id: 'docs', reason: 'nope' }]
+    )
+  })
+
+  it('never rejects', async () => {
+    flag.mockReturnValue(entries)
+    setupRagIndexing.mockRejectedValue(new Error('boom'))
+    await expect(autoprovisionAssistants(client)).resolves.toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'failed',
+      expect.any(Error)
+    )
+  })
+})

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

@@ -1,4 +1,4 @@
-export const AUTOPROVISION_FLAG: "rag.assistants.autoprovision";
+export const AUTOPROVISION_FLAG: "cozy.assistant.autoprovision";
 export function assistantIdFromName(name: any): string;
 export function getDefaultProvisionedAssistantId(): string | null;
 export function isMagicFolderId(dirId: any): boolean;

package/dist/components/KnowledgeBase/provisioning.js

@@ -27,7 +27,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var AUTOPROVISION_FLAG = 'rag.assistants.autoprovision';
+var AUTOPROVISION_FLAG = 'cozy.assistant.autoprovision';
 exports.AUTOPROVISION_FLAG = AUTOPROVISION_FLAG;
 var ASSISTANTS_DOCTYPE = 'io.cozy.ai.chat.assistants';
 var APPS_DOCTYPE = 'io.cozy.apps';
@@ -390,7 +390,7 @@ var validate = function validate(entry) {
   };
 };
 /**
- * Provisions the assistants described by the rag.assistants.autoprovision
+ * Provisions the assistants described by the cozy.assistant.autoprovision
  * flag. Idempotent: an existing assistant is left alone, or gets the flag's
  * folder back when it lost it or fell back to the root. Two entries whose
  * names derive to the same id would fight over one assistant: the second

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

@@ -485,6 +485,6 @@ describe('getDefaultProvisionedAssistantId', () => {
       { name: 'Autre', dirName: 'Autre', default: true }
     ])
     expect(getDefaultProvisionedAssistantId()).toBe('mes-documents')
-    expect(flag).toHaveBeenCalledWith('rag.assistants.autoprovision')
+    expect(flag).toHaveBeenCalledWith('cozy.assistant.autoprovision')
   })
 })

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

@@ -0,0 +1 @@
+export function useAssistantsAutoprovision(): void;

package/dist/components/KnowledgeBase/useAssistantsAutoprovision.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAssistantsAutoprovision = void 0;
+
+var _react = require("react");
+
+var _cozyClient = require("cozy-client");
+
+var _autoprovision = require("./autoprovision");
+
+/**
+ * Provisions the flagged assistants when the assistant UI opens, so an
+ * instance gets them even if the host app did not do it at startup.
+ */
+var useAssistantsAutoprovision = function useAssistantsAutoprovision() {
+  var client = (0, _cozyClient.useClient)();
+  (0, _react.useEffect)(function () {
+    if (client) (0, _autoprovision.autoprovisionAssistants)(client);
+  }, [client]);
+};
+
+exports.useAssistantsAutoprovision = useAssistantsAutoprovision;

package/dist/components/KnowledgeBase/useAssistantsAutoprovision.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,33 @@
+import { renderHook } from '@testing-library/react-hooks/dom'
+
+import { useClient } from 'cozy-client'
+
+import { autoprovisionAssistants } from './autoprovision'
+import { useAssistantsAutoprovision } from './useAssistantsAutoprovision'
+
+jest.mock('cozy-client', () => ({ useClient: jest.fn() }))
+jest.mock('./autoprovision', () => ({ autoprovisionAssistants: jest.fn() }))
+
+describe('useAssistantsAutoprovision', () => {
+  beforeEach(() => {
+    useClient.mockReset()
+    autoprovisionAssistants.mockReset().mockResolvedValue(null)
+  })
+
+  it('provisions with the client on mount', () => {
+    const client = { id: 'client' }
+    useClient.mockReturnValue(client)
+    const { rerender } = renderHook(() => useAssistantsAutoprovision())
+    rerender()
+
+    expect(autoprovisionAssistants).toHaveBeenCalledTimes(1)
+    expect(autoprovisionAssistants).toHaveBeenCalledWith(client)
+  })
+
+  it('waits for a client', () => {
+    useClient.mockReturnValue(null)
+    renderHook(() => useAssistantsAutoprovision())
+
+    expect(autoprovisionAssistants).not.toHaveBeenCalled()
+  })
+})

package/dist/components/queries.js

@@ -23,8 +23,7 @@ exports.ACCOUNTS_DOCTYPE = ACCOUNTS_DOCTYPE;
 var EMAIL_DOCTYPE = 'com.linagora.email';
 exports.EMAIL_DOCTYPE = EMAIL_DOCTYPE;
 
-var defaultFetchPolicy = _cozyClient.fetchPolicies.olderThan(86400); // 24 hours
-
+var defaultFetchPolicy = _cozyClient.fetchPolicies.olderThan(5 * 60 * 1000);
 
 var buildFilesByIds = function buildFilesByIds(ids, enabled) {
   return {

package/dist/index.d.ts

@@ -11,3 +11,5 @@ export { StreamBridge, createCozyRealtimeChatAdapter } from './components/adapte
 export { default as AssistantView } from './components/Views/AssistantView';
 export { assistantIdFromName, AUTOPROVISION_FLAG, ensureProvisionedAssistants, getDefaultProvisionedAssistantId } from './components/KnowledgeBase/provisioning';
 export { setupRagIndexing } from './components/KnowledgeBase/ragIndexing';
+export { autoprovisionAssistants } from './components/KnowledgeBase/autoprovision';
+export { useAssistantsAutoprovision } from './components/KnowledgeBase/useAssistantsAutoprovision';

package/dist/index.js

@@ -83,6 +83,12 @@ Object.defineProperty(exports, "assistantIdFromName", {
     return _provisioning.assistantIdFromName;
   }
 });
+Object.defineProperty(exports, "autoprovisionAssistants", {
+  enumerable: true,
+  get: function get() {
+    return _autoprovision.autoprovisionAssistants;
+  }
+});
 Object.defineProperty(exports, "createCozyRealtimeChatAdapter", {
   enumerable: true,
   get: function get() {
@@ -107,6 +113,12 @@ Object.defineProperty(exports, "setupRagIndexing", {
     return _ragIndexing.setupRagIndexing;
   }
 });
+Object.defineProperty(exports, "useAssistantsAutoprovision", {
+  enumerable: true,
+  get: function get() {
+    return _useAssistantsAutoprovision.useAssistantsAutoprovision;
+  }
+});
 
 var _AssistantLink = _interopRequireDefault(require("./components/Search/AssistantLink"));
 
@@ -132,4 +144,8 @@ var _AssistantView = _interopRequireDefault(require("./components/Views/Assistan
 
 var _provisioning = require("./components/KnowledgeBase/provisioning");
 
-var _ragIndexing = require("./components/KnowledgeBase/ragIndexing");
+var _ragIndexing = require("./components/KnowledgeBase/ragIndexing");
+
+var _autoprovision = require("./components/KnowledgeBase/autoprovision");
+
+var _useAssistantsAutoprovision = require("./components/KnowledgeBase/useAssistantsAutoprovision");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cozy-search",
   "description": "UI components about search bar and IA assistant",
-  "version": "2.3.3",
+  "version": "2.4.0",
   "author": {
     "name": "Cozy Cloud",
     "url": "https://github.com/cozy"
@@ -96,5 +96,5 @@
     "lint": "cd .. && yarn eslint --ext js,jsx,ts packages/cozy-search"
   },
   "types": "dist/index.d.ts",
-  "gitHead": "5269c3bcf245d4e9e47cbefd29286aa733602bb7"
+  "gitHead": "c1957ceb37bd485a80d871abc3d583238ef4f2e7"
 }