added is_synced to options to better differentiate between synced and not synced options

services/app_info.js

@@ -3,7 +3,7 @@
 const build = require('./build');
 const packageJson = require('../package');
 
-const APP_DB_VERSION = 66;
+const APP_DB_VERSION = 67;
 
 module.exports = {
     app_version: packageJson.version,

services/content_hash.js

@@ -16,8 +16,6 @@ function getHash(rows) {
 async function getHashes() {
     const startTime = new Date();
 
-    const optionsQuestionMarks = Array(options.SYNCED_OPTIONS.length).fill('?').join(',');
-
     const hashes = {
         notes: getHash(await sql.getAll(`
             SELECT
@@ -67,8 +65,8 @@ async function getHashes() {
              opt_name,
              opt_value 
            FROM options 
-           WHERE opt_name IN (${optionsQuestionMarks}) 
-           ORDER BY opt_name`, options.SYNCED_OPTIONS)),
+           WHERE is_synced = 1
+           ORDER BY opt_name`)),
 
         // we don't include image data on purpose because they are quite large, checksum is good enough
         // to represent the data anyway

services/options.js

@@ -3,10 +3,6 @@ const utils = require('./utils');
 const sync_table = require('./sync_table');
 const app_info = require('./app_info');
 
-const SYNCED_OPTIONS = [ 'username', 'password_verification_hash', 'password_verification_salt',
-    'password_derived_key_salt', 'encrypted_data_key', 'encrypted_data_key_iv',
-    'protected_session_timeout', 'history_snapshot_time_interval' ];
-
 async function getOption(optName) {
     const row = await sql.getFirstOrNull("SELECT opt_value FROM options WHERE opt_name = ?", [optName]);
 
@@ -17,43 +13,56 @@ async function getOption(optName) {
     return row['opt_value'];
 }
 
-async function setOption(optName, optValue, sourceId) {
-    if (SYNCED_OPTIONS.includes(optName)) {
+async function setOption(optName, optValue, sourceId = null) {
+    const opt = await sql.getFirst("SELECT * FROM options WHERE opt_name = ?", [optName]);
+
+    if (!opt) {
+        throw new Error(`Option ${optName} doesn't exist`);
+    }
+
+    if (opt.is_synced) {
         await sync_table.addOptionsSync(optName, sourceId);
     }
 
-    await sql.replace("options", {
-        opt_name: optName,
-        opt_value: optValue,
-        date_modified: utils.nowDate()
+    await sql.execute("UPDATE options SET opt_value = ?, date_modified = ? WHERE opt_name = ?",
+        [optValue, utils.nowDate(), optName]);
+}
+
+async function createOption(optName, optValue, isSynced, sourceId = null) {
+    await sql.insert("options", {
+       opt_name: optName,
+       opt_value: optValue,
+       is_synced: isSynced
     });
+
+    if (isSynced) {
+        await sync_table.addOptionsSync(optName, sourceId);
+    }
 }
 
 async function initOptions(startNotePath) {
-    await setOption('document_id', utils.randomSecureToken(16));
-    await setOption('document_secret', utils.randomSecureToken(16));
+    await createOption('document_id', utils.randomSecureToken(16), false);
+    await createOption('document_secret', utils.randomSecureToken(16), false);
 
-    await setOption('username', '');
-    await setOption('password_verification_hash', '');
-    await setOption('password_verification_salt', '');
-    await setOption('password_derived_key_salt', '');
-    await setOption('encrypted_data_key', '');
-    await setOption('encrypted_data_key_iv', '');
+    await createOption('username', '', true);
+    await createOption('password_verification_hash', '', true);
+    await createOption('password_verification_salt', '', true);
+    await createOption('password_derived_key_salt', '', true);
+    await createOption('encrypted_data_key', '', true);
+    await createOption('encrypted_data_key_iv', '', true);
 
-    await setOption('start_note_path', startNotePath);
-    await setOption('protected_session_timeout', 600);
-    await setOption('history_snapshot_time_interval', 600);
-    await setOption('last_backup_date', utils.nowDate());
-    await setOption('db_version', app_info.db_version);
+    await createOption('start_note_path', startNotePath, false);
+    await createOption('protected_session_timeout', 600, true);
+    await createOption('history_snapshot_time_interval', 600, true);
+    await createOption('last_backup_date', utils.nowDate(), false);
+    await createOption('db_version', app_info.db_version, false);
 
-    await setOption('last_synced_pull', app_info.db_version);
-    await setOption('last_synced_push', 0);
-    await setOption('last_synced_push', 0);
+    await createOption('last_synced_pull', app_info.db_version, false);
+    await createOption('last_synced_push', 0, false);
 }
 
 module.exports = {
     getOption,
     setOption,
-    initOptions,
-    SYNCED_OPTIONS
+    initOptions
 };

services/sync_update.js

@@ -1,6 +1,5 @@
 const sql = require('./sql');
 const log = require('./log');
-const options = require('./options');
 const eventLog = require('./event_log');
 const notes = require('./notes');
 const sync_table = require('./sync_table');
@@ -63,12 +62,12 @@ async function updateNoteReordering(entity, sourceId) {
 }
 
 async function updateOptions(entity, sourceId) {
-    if (!options.SYNCED_OPTIONS.includes(entity.opt_name)) {
+    const orig = await sql.getFirstOrNull("SELECT * FROM options WHERE opt_name = ?", [entity.opt_name]);
+
+    if (!orig.is_synced) {
         return;
     }
 
-    const orig = await sql.getFirstOrNull("SELECT * FROM options WHERE opt_name = ?", [entity.opt_name]);
-
     await sql.doInTransaction(async () => {
         if (orig === null || orig.date_modified < entity.date_modified) {
             await sql.replace('options', entity);