cozy-pouch-link 60.30.3 → 60.30.6

package/dist/db/sqlite/sqliteDb.native.js

@@ -39,6 +39,21 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
+// busy_timeout is per-connection, not per-database, and applies to the
+// statements issued after it. Two values are needed because the statements it
+// covers here do not run on the same thread:
+//
+//   - journal_mode=WAL runs through executeSync, ON the JS thread, and needs the
+//     write lock to switch. Under a replication batch it would wait for the
+//     whole timeout, freezing the UI, hence the short value. Losing that race is
+//     harmless: the mode is persistent, so the next open retries it, and it is a
+//     no-op once the database is already in WAL.
+//   - queries run through executeAsync, OFF the JS thread, so waiting costs
+//     latency rather than responsiveness. A short value there would make them
+//     fail during a bulk insert and fall back to pouch-find for no reason.
+var SETUP_BUSY_TIMEOUT_MS = 250;
+var QUERY_BUSY_TIMEOUT_MS = 5000;
+
 var SQLiteQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
   (0, _inherits2.default)(SQLiteQueryEngine, _DatabaseQueryEngine);
 
@@ -87,19 +102,31 @@ var SQLiteQueryEngine = /*#__PURE__*/function (_DatabaseQueryEngine) {
         },
         get: function get() {
           if (resolved) return resolved;
-          resolved = (0, _opSqlite.open)({
+          var handle = (0, _opSqlite.open)({
             name: fileDbName
+          }); // Each pragma is independent and best-effort: journal_mode can lose the
+          // race for the write lock, and sharing one try/catch would then skip the
+          // query timeout and strand the connection on the setup one.
+
+          var applyPragma = function applyPragma(sql) {
+            try {
+              handle.executeSync(sql);
+            } catch (err) {
+              _logger.default.error(err);
+            }
+          };
+
+          applyPragma("PRAGMA busy_timeout=".concat(SETUP_BUSY_TIMEOUT_MS));
+          applyPragma('PRAGMA journal_mode=WAL');
+          applyPragma("PRAGMA busy_timeout=".concat(QUERY_BUSY_TIMEOUT_MS));
+          resolved = handle;
+          Promise.resolve().then(function () {
+            return (0, _sql.executeSQL)(handle, (0, _sql.makeSQLCreateDocIDIndex)());
+          }).then(function () {
+            return (0, _sql.executeSQL)(handle, (0, _sql.makeSQLCreateDeletedIndex)());
+          }).catch(function (err) {
+            return _logger.default.error(err);
           });
-
-          try {
-            (0, _sql.executeSQL)(resolved, 'PRAGMA journal_mode=WAL');
-            (0, _sql.executeSQL)(resolved, 'PRAGMA busy_timeout=5000');
-            (0, _sql.executeSQL)(resolved, (0, _sql.makeSQLCreateDocIDIndex)());
-            (0, _sql.executeSQL)(resolved, (0, _sql.makeSQLCreateDeletedIndex)());
-          } catch (err) {
-            _logger.default.error(err);
-          }
-
           return resolved;
         }
       });

package/dist/db/sqlite/sqliteDb.native.spec.js

@@ -3,6 +3,8 @@ import PouchDBQueryEngine from '../pouchdb/pouchdb'
 import SQLiteQueryEngine from './sqliteDb.native'
 
 jest.mock('@op-engineering/op-sqlite', () => ({ open: jest.fn() }))
+
+import { open } from '@op-engineering/op-sqlite'
 jest.mock('../pouchdb/pouchdb')
 
 // The engine answers a query it cannot translate - or one SQLite rejects - by
@@ -68,3 +70,89 @@ describe('SQLiteQueryEngine find fallback', () => {
     expect(PouchDBQueryEngine).not.toHaveBeenCalled()
   })
 })
+
+describe('SQLiteQueryEngine openDB setup', () => {
+  const setup = ({ createIndexFails = false } = {}) => {
+    const executeSync = jest.fn()
+    const executeAsync = jest.fn(() =>
+      createIndexFails
+        ? Promise.reject(new Error('database is locked'))
+        : Promise.resolve({ rows: { length: 0, item: () => undefined } })
+    )
+    open.mockReturnValue({ executeSync, executeAsync })
+    const engine = new SQLiteQueryEngine({ client: {} }, 'io.cozy.files')
+    engine.openDB('cozy-files')
+    return { engine, executeSync, executeAsync }
+  }
+
+  it('applies the pragmas synchronously so a query cannot outrun them', () => {
+    const { engine, executeSync } = setup()
+
+    expect(engine.db).toBeDefined()
+    expect(executeSync).toHaveBeenCalled()
+  })
+
+  it('sets busy_timeout before switching the journal mode', () => {
+    const { engine, executeSync } = setup()
+    void engine.db
+
+    const statements = executeSync.mock.calls.map(([sql]) => sql)
+    const firstTimeout = statements.findIndex(sql =>
+      sql.includes('busy_timeout')
+    )
+    const journalMode = statements.findIndex(sql =>
+      sql.includes('journal_mode')
+    )
+
+    expect(firstTimeout).toBeGreaterThanOrEqual(0)
+    expect(journalMode).toBeGreaterThan(firstTimeout)
+  })
+
+  it('keeps a locked CREATE INDEX from becoming an unhandled rejection', async () => {
+    const { engine } = setup({ createIndexFails: true })
+    const unhandled = jest.fn()
+    process.on('unhandledRejection', unhandled)
+
+    void engine.db
+    await new Promise(resolve => setImmediate(resolve))
+    await new Promise(resolve => setImmediate(resolve))
+
+    process.off('unhandledRejection', unhandled)
+    expect(unhandled).not.toHaveBeenCalled()
+  })
+
+  it('still returns a usable handle when the pragmas throw', () => {
+    open.mockReturnValue({
+      executeSync: jest.fn(() => {
+        throw new Error('database is locked')
+      }),
+      executeAsync: jest.fn().mockResolvedValue({})
+    })
+    const engine = new SQLiteQueryEngine({ client: {} }, 'io.cozy.files')
+    engine.openDB('cozy-files')
+
+    expect(engine.db).toBeDefined()
+  })
+
+  it('still raises the query timeout when the journal-mode switch is refused', () => {
+    const executeSync = jest.fn(sql => {
+      if (sql.includes('journal_mode')) {
+        throw new Error('database is locked')
+      }
+    })
+    open.mockReturnValue({
+      executeSync,
+      executeAsync: jest.fn().mockResolvedValue({})
+    })
+    const engine = new SQLiteQueryEngine({ client: {} }, 'io.cozy.files')
+    engine.openDB('cozy-files')
+
+    void engine.db
+
+    const timeouts = executeSync.mock.calls
+      .map(([sql]) => sql)
+      .filter(sql => sql.includes('busy_timeout'))
+    expect(timeouts).toHaveLength(2)
+    expect(timeouts[timeouts.length - 1]).toContain('5000')
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "60.30.3",
+  "version": "60.30.6",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/linagora/cozy-client.git"
   },
   "dependencies": {
-    "cozy-client": "^60.30.1",
+    "cozy-client": "^60.30.6",
     "pouchdb-browser": "^7.2.2",
     "pouchdb-find": "^7.2.2"
   },
@@ -41,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "6dc10895e420d7f6f0782b029a55af82e052e11a"
+  "gitHead": "88101a3d13943828cd1cfcf39c40535c0a259afa"
 }