@vrtmrz/livesync-commonlib 0.1.34 → 0.1.36

package/dist/common/models/setting.policy.js

@@ -0,0 +1,298 @@
+import { DEFAULT_SETTINGS } from "./setting.const.defaults.js";
+const SettingPolicies = {
+  Default: { markdown: "include", persistence: "include" },
+  LocalOnly: { markdown: "omit", persistence: "include" },
+  DeviceLocal: { markdown: "include", persistence: "device" },
+  MarkdownCredentials: { markdown: "credentials", persistence: "include" },
+  RemoteProfiles: { markdown: "credentials", persistence: "profiles" },
+  LocalConnection: { markdown: "include", persistence: "connection" },
+  ConnectionCredentials: { markdown: "credentials", persistence: "connection" },
+  ConnectionContext: { markdown: "include", persistence: "connection-context" },
+  E2EEPassphrase: { markdown: "credentials", persistence: "passphrase" },
+  IdDerivationKey: { markdown: "credentials", persistence: "id-key" },
+  RuntimeOnly: { markdown: "omit", persistence: "omit" }
+};
+const SETTINGS_PROPERTY_POLICY = {
+  liveSync: SettingPolicies.Default,
+  syncOnSave: SettingPolicies.Default,
+  syncOnStart: SettingPolicies.Default,
+  syncOnFileOpen: SettingPolicies.Default,
+  syncOnEditorSave: SettingPolicies.Default,
+  keepReplicationActiveInBackground: SettingPolicies.Default,
+  allowSleepDuringSynchronisation: SettingPolicies.Default,
+  allowSleepDuringSynchronisationOnDesktop: SettingPolicies.Default,
+  syncMinimumInterval: SettingPolicies.Default,
+  showVerboseLog: SettingPolicies.Default,
+  lessInformationInLog: SettingPolicies.Default,
+  showLongerLogInsideEditor: SettingPolicies.Default,
+  showStatusOnEditor: SettingPolicies.Default,
+  showStatusOnStatusbar: SettingPolicies.Default,
+  showOnlyIconsOnEditor: SettingPolicies.Default,
+  hideFileWarningNotice: SettingPolicies.Default,
+  networkWarningStyle: SettingPolicies.Default,
+  displayLanguage: SettingPolicies.Default,
+  trashInsteadDelete: SettingPolicies.Default,
+  doNotDeleteFolder: SettingPolicies.Default,
+  batchSave: SettingPolicies.Default,
+  batchSaveMinimumDelay: SettingPolicies.Default,
+  batchSaveMaximumDelay: SettingPolicies.Default,
+  syncMaxSizeInMB: SettingPolicies.Default,
+  useIgnoreFiles: SettingPolicies.Default,
+  ignoreFiles: SettingPolicies.Default,
+  processSizeMismatchedFiles: SettingPolicies.Default,
+  syncOnlyRegEx: SettingPolicies.Default,
+  syncIgnoreRegEx: SettingPolicies.Default,
+  syncAfterMerge: SettingPolicies.Default,
+  resolveConflictsByNewerFile: SettingPolicies.Default,
+  writeDocumentsIfConflicted: SettingPolicies.Default,
+  disableMarkdownAutoMerge: SettingPolicies.Default,
+  configPassphraseStore: SettingPolicies.Default,
+  encryptedPassphrase: SettingPolicies.LocalOnly,
+  encryptedIdDerivationKey: SettingPolicies.LocalOnly,
+  encryptedCouchDBConnection: SettingPolicies.LocalOnly,
+  periodicReplication: SettingPolicies.Default,
+  periodicReplicationInterval: SettingPolicies.Default,
+  syncInternalFiles: SettingPolicies.Default,
+  syncInternalFilesBeforeReplication: SettingPolicies.Default,
+  syncInternalFilesInterval: SettingPolicies.Default,
+  syncInternalFilesIgnorePatterns: SettingPolicies.Default,
+  syncInternalFilesTargetPatterns: SettingPolicies.Default,
+  watchInternalFileChanges: SettingPolicies.Default,
+  suppressNotifyHiddenFilesChange: SettingPolicies.Default,
+  syncInternalFileOverwritePatterns: SettingPolicies.Default,
+  usePluginSync: SettingPolicies.Default,
+  usePluginSettings: SettingPolicies.Default,
+  showOwnPlugins: SettingPolicies.Default,
+  autoSweepPlugins: SettingPolicies.Default,
+  autoSweepPluginsPeriodic: SettingPolicies.Default,
+  notifyPluginOrSettingUpdated: SettingPolicies.Default,
+  deviceAndVaultName: SettingPolicies.DeviceLocal,
+  usePluginSyncV2: SettingPolicies.Default,
+  usePluginEtc: SettingPolicies.Default,
+  pluginSyncExtendedSetting: SettingPolicies.Default,
+  useAdvancedMode: SettingPolicies.Default,
+  usePowerUserMode: SettingPolicies.Default,
+  useEdgeCaseMode: SettingPolicies.Default,
+  notifyThresholdOfRemoteStorageSize: SettingPolicies.Default,
+  disableWorkerForGeneratingChunks: SettingPolicies.Default,
+  processSmallFilesInUIThread: SettingPolicies.Default,
+  savingDelay: SettingPolicies.Default,
+  gcDelay: SettingPolicies.Default,
+  skipOlderFilesOnSync: SettingPolicies.Default,
+  useIndexedDBAdapter: SettingPolicies.Default,
+  enableDebugTools: SettingPolicies.Default,
+  writeLogToTheFile: SettingPolicies.Default,
+  settingSyncFile: SettingPolicies.Default,
+  writeCredentialsForSettingSync: SettingPolicies.Default,
+  notifyAllSettingSyncFile: SettingPolicies.Default,
+  suspendFileWatching: SettingPolicies.Default,
+  suspendParseReplicationResult: SettingPolicies.Default,
+  doNotSuspendOnFetching: SettingPolicies.Default,
+  maxMTimeForReflectEvents: SettingPolicies.Default,
+  versionUpFlash: SettingPolicies.Default,
+  settingVersion: SettingPolicies.Default,
+  isConfigured: SettingPolicies.Default,
+  lastReadUpdates: SettingPolicies.Default,
+  doctorProcessedVersion: SettingPolicies.Default,
+  remoteConfigurations: SettingPolicies.RemoteProfiles,
+  activeConfigurationId: SettingPolicies.MarkdownCredentials,
+  P2P_ActiveRemoteConfigurationId: SettingPolicies.MarkdownCredentials,
+  couchDB_URI: SettingPolicies.LocalConnection,
+  couchDB_USER: SettingPolicies.ConnectionCredentials,
+  couchDB_PASSWORD: SettingPolicies.ConnectionCredentials,
+  couchDB_DBNAME: SettingPolicies.LocalConnection,
+  couchDB_CustomHeaders: SettingPolicies.ConnectionCredentials,
+  useJWT: SettingPolicies.Default,
+  jwtAlgorithm: SettingPolicies.Default,
+  jwtKey: SettingPolicies.ConnectionCredentials,
+  jwtKid: SettingPolicies.ConnectionCredentials,
+  jwtSub: SettingPolicies.ConnectionCredentials,
+  jwtExpDuration: SettingPolicies.Default,
+  useRequestAPI: SettingPolicies.Default,
+  accessKey: SettingPolicies.ConnectionCredentials,
+  secretKey: SettingPolicies.ConnectionCredentials,
+  bucket: SettingPolicies.LocalConnection,
+  region: SettingPolicies.ConnectionContext,
+  endpoint: SettingPolicies.LocalConnection,
+  useCustomRequestHandler: SettingPolicies.Default,
+  bucketCustomHeaders: SettingPolicies.ConnectionCredentials,
+  bucketPrefix: SettingPolicies.Default,
+  forcePathStyle: SettingPolicies.Default,
+  remoteType: SettingPolicies.Default,
+  encrypt: SettingPolicies.Default,
+  passphrase: SettingPolicies.E2EEPassphrase,
+  idDerivationVersion: SettingPolicies.MarkdownCredentials,
+  idDerivationKey: SettingPolicies.IdDerivationKey,
+  usePathObfuscation: SettingPolicies.Default,
+  encryptInternalMetadata: SettingPolicies.Default,
+  E2EEAlgorithm: SettingPolicies.Default,
+  hashAlg: SettingPolicies.Default,
+  minimumChunkSize: SettingPolicies.Default,
+  customChunkSize: SettingPolicies.Default,
+  longLineThreshold: SettingPolicies.Default,
+  useSegmenter: SettingPolicies.Default,
+  enableChunkSplitterV2: SettingPolicies.Default,
+  doNotUseFixedRevisionForChunks: SettingPolicies.Default,
+  chunkSplitterVersion: SettingPolicies.Default,
+  useEden: SettingPolicies.Default,
+  maxChunksInEden: SettingPolicies.Default,
+  maxTotalLengthInEden: SettingPolicies.Default,
+  maxAgeInEden: SettingPolicies.Default,
+  tweakModified: SettingPolicies.Default,
+  checkIntegrityOnSave: SettingPolicies.Default,
+  useHistory: SettingPolicies.Default,
+  disableRequestURI: SettingPolicies.Default,
+  sendChunksBulk: SettingPolicies.Default,
+  sendChunksBulkMaxSize: SettingPolicies.Default,
+  useDynamicIterationCount: SettingPolicies.Default,
+  doNotPaceReplication: SettingPolicies.Default,
+  readChunksOnline: SettingPolicies.Default,
+  useOnlyLocalChunk: SettingPolicies.Default,
+  concurrencyOfReadChunksOnline: SettingPolicies.Default,
+  minimumIntervalOfReadChunksOnline: SettingPolicies.Default,
+  enableCompression: SettingPolicies.Default,
+  batch_size: SettingPolicies.Default,
+  batches_limit: SettingPolicies.Default,
+  ignoreVersionCheck: SettingPolicies.Default,
+  disableCheckingConfigMismatch: SettingPolicies.Default,
+  autoAcceptCompatibleTweak: SettingPolicies.Default,
+  hashCacheMaxCount: SettingPolicies.Default,
+  hashCacheMaxAmount: SettingPolicies.Default,
+  permitEmptyPassphrase: SettingPolicies.Default,
+  handleFilenameCaseSensitive: SettingPolicies.Default,
+  checkConflictOnlyOnOpen: SettingPolicies.Default,
+  showMergeDialogOnlyOnActive: SettingPolicies.Default,
+  additionalSuffixOfDatabaseName: SettingPolicies.LocalOnly,
+  useTimeouts: SettingPolicies.Default,
+  deleteMetadataOfDeletedFiles: SettingPolicies.Default,
+  automaticallyDeleteMetadataOfDeletedFiles: SettingPolicies.Default,
+  P2P_AutoAccepting: SettingPolicies.Default,
+  P2P_AutoSyncPeers: SettingPolicies.Default,
+  P2P_AutoWatchPeers: SettingPolicies.Default,
+  P2P_SyncOnReplication: SettingPolicies.Default,
+  P2P_RebuildFrom: SettingPolicies.Default,
+  P2P_AutoAcceptingPeers: SettingPolicies.Default,
+  P2P_AutoDenyingPeers: SettingPolicies.Default,
+  P2P_IsHeadless: SettingPolicies.Default,
+  P2P_iceServers: SettingPolicies.RuntimeOnly,
+  P2P_iceServersExpiresAt: SettingPolicies.RuntimeOnly,
+  P2P_Enabled: SettingPolicies.Default,
+  P2P_relays: SettingPolicies.Default,
+  P2P_roomID: SettingPolicies.Default,
+  P2P_passphrase: SettingPolicies.MarkdownCredentials,
+  P2P_AppID: SettingPolicies.Default,
+  P2P_AutoStart: SettingPolicies.Default,
+  P2P_AutoBroadcast: SettingPolicies.Default,
+  P2P_DevicePeerName: SettingPolicies.DeviceLocal,
+  P2P_turnServers: SettingPolicies.Default,
+  P2P_turnUsername: SettingPolicies.MarkdownCredentials,
+  P2P_turnCredential: SettingPolicies.MarkdownCredentials,
+  P2P_managedType: SettingPolicies.RuntimeOnly,
+  P2P_managedId: SettingPolicies.RuntimeOnly,
+  P2P_managedToken: SettingPolicies.RuntimeOnly,
+  P2P_maxWirePayloadBytes: SettingPolicies.Default,
+  P2P_connectionPath: SettingPolicies.Default,
+  P2P_useDiagRTC: SettingPolicies.Default
+};
+const settingKeys = Object.keys(SETTINGS_PROPERTY_POLICY);
+const protectedConnectionKeys = settingKeys.filter(
+  (key) => SETTINGS_PROPERTY_POLICY[key].persistence === "connection"
+);
+const connectionKeys = settingKeys.filter(
+  (key) => SETTINGS_PROPERTY_POLICY[key].persistence === "connection" || SETTINGS_PROPERTY_POLICY[key].persistence === "connection-context"
+);
+const omittedPersistenceKeys = settingKeys.filter((key) => SETTINGS_PROPERTY_POLICY[key].persistence === "omit");
+function copySetting(target, source, key) {
+  if (key in source) target[key] = source[key];
+  else delete target[key];
+}
+function cloneProfiles(settings) {
+  const profiles = {};
+  for (const [id, profile] of Object.entries(settings.remoteConfigurations ?? {})) {
+    Object.defineProperty(profiles, id, {
+      value: { ...profile },
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return profiles;
+}
+function createMarkdownSettings(settings, includeCredentials = settings.writeCredentialsForSettingSync === true) {
+  const output = {};
+  for (const key of settingKeys) {
+    const action = SETTINGS_PROPERTY_POLICY[key].markdown;
+    if (action === "omit" || action === "credentials" && !includeCredentials) continue;
+    copySetting(output, settings, key);
+  }
+  if (output.remoteConfigurations) output.remoteConfigurations = cloneProfiles(output);
+  return output;
+}
+function mergeMarkdownSettings(incoming, current) {
+  const merged = { ...DEFAULT_SETTINGS, ...incoming };
+  for (const key of settingKeys) {
+    const action = SETTINGS_PROPERTY_POLICY[key].markdown;
+    if (action === "omit" || action === "credentials" && merged.writeCredentialsForSettingSync !== true) {
+      copySetting(merged, current, key);
+    }
+  }
+  merged.remoteConfigurations = cloneProfiles(merged);
+  return merged;
+}
+function selectConnectionSettings(settings) {
+  const connection = {};
+  for (const key of connectionKeys) connection[key] = settings[key];
+  return connection;
+}
+function hasConnectionSettings(settings) {
+  return protectedConnectionKeys.some((key) => settings[key] !== "");
+}
+function clearConnectionSettings(settings) {
+  for (const key of connectionKeys) settings[key] = "";
+}
+function restoreConnectionSettings(settings, payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return false;
+  const connection = payload;
+  if (connectionKeys.some((key) => key in connection && typeof connection[key] !== "string")) return false;
+  for (const key of connectionKeys) {
+    if (key in connection) settings[key] = connection[key];
+  }
+  return true;
+}
+function omitUnpersistedSettings(settings) {
+  for (const key of omittedPersistenceKeys) delete settings[key];
+}
+function requireConfigurationCiphertext(value) {
+  if (value === "") throw new Error("Failed to encrypt configuration. Settings were not saved.");
+  return value;
+}
+function prepareSettingsForPersistence(settings) {
+  if (hasConnectionSettings(settings)) throw new Error("Connection settings were not prepared for persistence.");
+  if (settings.encrypt && settings.passphrase !== "")
+    throw new Error("The passphrase was not prepared for persistence.");
+  if (settings.idDerivationVersion === 1 && settings.idDerivationKey !== "") {
+    throw new Error("The ID derivation key was not prepared for persistence.");
+  }
+  if (omittedPersistenceKeys.some((key) => key in settings)) {
+    throw new Error("Runtime settings were not removed before persistence.");
+  }
+  if (settings.configPassphraseStore !== "" && Object.values(settings.remoteConfigurations).some(
+    (profile) => profile.uri.trim() !== "" && !profile.isEncrypted
+  )) {
+    throw new Error("Remote configurations were not prepared for persistence.");
+  }
+  return settings;
+}
+export {
+  SETTINGS_PROPERTY_POLICY,
+  SettingPolicies,
+  clearConnectionSettings,
+  createMarkdownSettings,
+  hasConnectionSettings,
+  mergeMarkdownSettings,
+  omitUnpersistedSettings,
+  prepareSettingsForPersistence,
+  requireConfigurationCiphertext,
+  restoreConnectionSettings,
+  selectConnectionSettings
+};

package/dist/common/utils.patch.js

@@ -2,6 +2,17 @@ const MARK_OPERATOR = `
`;
 const MARK_DELETED = `${MARK_OPERATOR}__DELETED`;
 const MARK_ISARRAY = `${MARK_OPERATOR}__ARRAY`;
 const MARK_SWAPPED = `${MARK_OPERATOR}__SWAP`;
+function hasOwnProperty(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+function setOwnProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
 function unorderedArrayToObject(obj) {
   return obj.map((e) => ({ [e.id]: e })).reduce((p, c) => ({ ...p, ...c }), {});
 }
@@ -30,34 +41,34 @@ function generatePatchObj(from, to) {
   const newEntries = Object.entries(to);
   for (const [key, value] of newEntries) {
     if (!tempMap.has(key)) {
-      ret[key] = value;
+      setOwnProperty(ret, key, value);
       tempMap.delete(key);
     } else {
       const v = tempMap.get(key);
       if (typeof v !== typeof value || Array.isArray(v) !== Array.isArray(value)) {
-        ret[key] = { [MARK_SWAPPED]: value };
+        setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
       } else {
         if (v === null && value === null) {
         } else if (v === null && value !== null) {
-          ret[key] = { [MARK_SWAPPED]: value };
+          setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
         } else if (v !== null && value === null) {
-          ret[key] = { [MARK_SWAPPED]: value };
+          setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
         } else if (typeof v == "object" && typeof value == "object" && !Array.isArray(v) && !Array.isArray(value)) {
           const wk = generatePatchObj(
             v,
             value
           );
-          if (Object.keys(wk).length > 0) ret[key] = wk;
+          if (Object.keys(wk).length > 0) setOwnProperty(ret, key, wk);
         } else if (typeof v == "object" && typeof value == "object" && Array.isArray(v) && Array.isArray(value)) {
           const wk = generatePatchUnorderedArray(v, value);
-          if (Object.keys(wk).length > 0) ret[key] = wk;
+          if (Object.keys(wk).length > 0) setOwnProperty(ret, key, wk);
         } else if (typeof v != "object" && typeof value != "object") {
           if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
-            ret[key] = value;
+            setOwnProperty(ret, key, value);
           }
         } else {
           if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
-            ret[key] = { [MARK_SWAPPED]: value };
+            setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
           }
         }
       }
@@ -65,7 +76,7 @@ function generatePatchObj(from, to) {
     }
   }
   for (const [key] of tempMap) {
-    ret[key] = MARK_DELETED;
+    setOwnProperty(ret, key, MARK_DELETED);
   }
   return ret;
 }
@@ -73,21 +84,21 @@ function applyPatch(from, patch) {
   const ret = from;
   const patches = Object.entries(patch);
   for (const [key, value] of patches) {
-    if (value == MARK_DELETED) {
+    if (value === MARK_DELETED) {
       delete ret[key];
       continue;
     }
     if (value === null) {
-      ret[key] = null;
+      setOwnProperty(ret, key, null);
       continue;
     }
     if (typeof value == "object") {
-      if (MARK_SWAPPED in value) {
-        ret[key] = value[MARK_SWAPPED];
+      if (hasOwnProperty(value, MARK_SWAPPED)) {
+        setOwnProperty(ret, key, value[MARK_SWAPPED]);
         continue;
       }
-      if (MARK_ISARRAY in value) {
-        if (!(key in ret)) ret[key] = [];
+      if (hasOwnProperty(value, MARK_ISARRAY)) {
+        if (!hasOwnProperty(ret, key)) setOwnProperty(ret, key, []);
         if (!Array.isArray(ret[key])) {
           throw new Error("Patch target type is mismatched (array to something)");
         }
@@ -97,19 +108,23 @@ function applyPatch(from, patch) {
           value[MARK_ISARRAY]
         );
         const appliedArray = objectToUnorderedArray(appliedObject);
-        ret[key] = [...appliedArray];
+        setOwnProperty(ret, key, [...appliedArray]);
       } else {
-        if (!(key in ret)) {
-          ret[key] = value;
+        if (!hasOwnProperty(ret, key)) {
+          setOwnProperty(ret, key, value);
           continue;
         }
-        ret[key] = applyPatch(
-          ret[key],
-          value
+        setOwnProperty(
+          ret,
+          key,
+          applyPatch(
+            ret[key],
+            value
+          )
         );
       }
     } else {
-      ret[key] = value;
+      setOwnProperty(ret, key, value);
     }
   }
   return ret;
@@ -121,24 +136,28 @@ function mergeObject(objA, objB) {
     return objB;
   }
   for (const [key, v] of newEntries) {
-    if (key in ret) {
+    if (hasOwnProperty(ret, key)) {
       const value = ret[key];
       if (typeof v !== typeof value || Array.isArray(v) !== Array.isArray(value)) {
-        ret[key] = v;
+        setOwnProperty(ret, key, v);
       } else {
         if (typeof v == "object" && typeof value == "object" && !Array.isArray(v) && !Array.isArray(value)) {
-          ret[key] = mergeObject(
-            v,
-            value
+          setOwnProperty(
+            ret,
+            key,
+            mergeObject(
+              v,
+              value
+            )
           );
         } else if (typeof v == "object" && typeof value == "object" && Array.isArray(v) && Array.isArray(value)) {
-          ret[key] = [.../* @__PURE__ */ new Set([...v, ...value])];
+          setOwnProperty(ret, key, [.../* @__PURE__ */ new Set([...v, ...value])]);
         } else {
-          ret[key] = v;
+          setOwnProperty(ret, key, v);
         }
       }
     } else {
-      ret[key] = v;
+      setOwnProperty(ret, key, v);
     }
   }
   const retSorted = Object.fromEntries(Object.entries(ret).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));

package/dist/services/base/RemoteService.js

@@ -226,7 +226,7 @@ class RemoteService extends ServiceBase {
             const signal = connectionScope.combine(opts?.signal);
             const response = await this.performFetch(
               requestSrc,
-              { ...opts, headers, signal },
+              { ...opts, headers, signal, cache: "no-store" },
               useRequestAPI ? FetchMethod.native : FetchMethod.webCompat
             );
             return response;
@@ -242,7 +242,11 @@ class RemoteService extends ServiceBase {
               this._log(
                 "Failed to fetch by native fetch API. Trying to fetch by API to get more information."
               );
-              const resp2 = await this.performFetch(requestSrc, { ...opts, headers }, FetchMethod.native);
+              const resp2 = await this.performFetch(
+                requestSrc,
+                { ...opts, headers, cache: "no-store" },
+                FetchMethod.native
+              );
               if (resp2.status / 100 == 2) {
                 this.showError(
                   "The request was successful by API. But the native fetch API failed! Please check CORS settings on the remote database!. While this condition, you cannot enable LiveSync",

package/dist/services/base/SettingService.d.ts

@@ -2,6 +2,7 @@ import { type ObsidianLiveSyncSettings, type SettingsMigrationState } from "../.
 import type { IAPIService, ISettingService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
 import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { type PersistedSettings } from "../../common/models/setting.policy.js";
 export interface SettingServiceDependencies {
     APIService: IAPIService;
     /** Optional host hook for applying the loaded display language to its catalogue. */
@@ -17,7 +18,7 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     _settings: ObsidianLiveSyncSettings;
     get settings(): ObsidianLiveSyncSettings;
     set settings(value: ObsidianLiveSyncSettings);
-    protected abstract saveData(setting: ObsidianLiveSyncSettings): Promise<void>;
+    protected abstract saveData(setting: PersistedSettings): Promise<void>;
     protected abstract loadData(): Promise<ObsidianLiveSyncSettings | undefined>;
     private _lastPersistedSettings?;
     private _settingsMigrationState?;

package/dist/services/base/SettingService.js

@@ -22,6 +22,15 @@ import {
 } from "../../serviceFeatures/remoteConfig.js";
 import { ConnectionStringParser } from "../../common/ConnectionString.js";
 import { configuredIdKey } from "../../common/idDerivation.js";
+import {
+  clearConnectionSettings,
+  hasConnectionSettings,
+  omitUnpersistedSettings,
+  prepareSettingsForPersistence,
+  requireConfigurationCiphertext,
+  restoreConnectionSettings,
+  selectConnectionSettings
+} from "../../common/models/setting.policy.js";
 class SettingService extends ServiceBase {
   deviceAndVaultName = "";
   APIService;
@@ -185,62 +194,46 @@ class SettingService extends ServiceBase {
       this.setSmallConfig(SETTING_KEY_P2P_DEVICE_NAME, settings.P2P_DevicePeerName.trim());
       settings.P2P_DevicePeerName = "";
     }
-    delete settings.P2P_managedType;
-    delete settings.P2P_managedId;
-    delete settings.P2P_managedToken;
-    if (this.usedPassphrase == "" && !await this.getPassphrase(settings)) {
+    omitUnpersistedSettings(settings);
+    const configurationPassphrase = this.usedPassphrase || await this.getPassphrase(settings);
+    if (!configurationPassphrase) {
       if (Object.values(settings.remoteConfigurations).some((config) => this.hasManagedP2PProfileURI(config.uri))) {
         const message = "Failed to retrieve a passphrase for managed P2P source data. Settings were not saved.";
         this._log(message, LOG_LEVEL_URGENT);
         throw new Error(message);
       }
+      if (hasConnectionSettings(settings) || settings.encrypt && settings.passphrase !== "" || settings.configPassphraseStore !== "" && Object.values(settings.remoteConfigurations).some(
+        (config) => !config.isEncrypted && config.uri.trim() !== ""
+      )) {
+        const message = "Failed to retrieve a configuration passphrase. Settings were not saved.";
+        this._log(message, LOG_LEVEL_URGENT);
+        throw new Error(message);
+      }
       this._log("Failed to retrieve passphrase. data.json contains unencrypted items!", LOG_LEVEL_NOTICE);
     } else {
-      if (settings.couchDB_PASSWORD != "" || settings.couchDB_URI != "" || settings.couchDB_USER != "" || settings.couchDB_DBNAME) {
-        const connectionSetting = {
-          couchDB_DBNAME: settings.couchDB_DBNAME,
-          couchDB_PASSWORD: settings.couchDB_PASSWORD,
-          couchDB_URI: settings.couchDB_URI,
-          couchDB_USER: settings.couchDB_USER,
-          accessKey: settings.accessKey,
-          bucket: settings.bucket,
-          endpoint: settings.endpoint,
-          region: settings.region,
-          secretKey: settings.secretKey,
-          useCustomRequestHandler: settings.useCustomRequestHandler,
-          bucketCustomHeaders: settings.bucketCustomHeaders,
-          couchDB_CustomHeaders: settings.couchDB_CustomHeaders,
-          useJWT: settings.useJWT,
-          jwtKey: settings.jwtKey,
-          jwtAlgorithm: settings.jwtAlgorithm,
-          jwtKid: settings.jwtKid,
-          jwtExpDuration: settings.jwtExpDuration,
-          jwtSub: settings.jwtSub,
-          useRequestAPI: settings.useRequestAPI,
-          bucketPrefix: settings.bucketPrefix,
-          forcePathStyle: settings.forcePathStyle
-        };
-        settings.encryptedCouchDBConnection = await this.encryptConfigurationItem(
-          JSON.stringify(connectionSetting),
-          settings
+      if (hasConnectionSettings(settings)) {
+        settings.encryptedCouchDBConnection = requireConfigurationCiphertext(
+          await this.encryptConfigurationItem(JSON.stringify(selectConnectionSettings(settings)), settings)
+        );
+        clearConnectionSettings(settings);
+      } else if (settings.encryptedCouchDBConnection) {
+        const existingConnection = this.tryDecodeJson(
+          await this.decryptConfigurationItem(settings.encryptedCouchDBConnection, configurationPassphrase)
         );
-        settings.couchDB_PASSWORD = "";
-        settings.couchDB_DBNAME = "";
-        settings.couchDB_URI = "";
-        settings.couchDB_USER = "";
-        settings.accessKey = "";
-        settings.bucket = "";
-        settings.region = "";
-        settings.secretKey = "";
-        settings.endpoint = "";
+        if (restoreConnectionSettings(this.cloneSettings(settings), existingConnection)) {
+          settings.encryptedCouchDBConnection = "";
+        }
       }
       if (settings.encrypt && settings.passphrase != "") {
-        settings.encryptedPassphrase = await this.encryptPlainConfigurationItem(settings.passphrase, settings);
+        settings.encryptedPassphrase = requireConfigurationCiphertext(
+          await this.encryptPlainConfigurationItem(settings.passphrase, settings)
+        );
         settings.passphrase = "";
       }
       await this.encryptRemoteConfigurationUris(settings);
     }
-    await this.saveData(settings);
+    const persisted = prepareSettingsForPersistence(settings);
+    await this.saveData(persisted);
     this._lastPersistedSettings = this.cloneSettings(this.settings);
     void this.onSettingSaved(settings);
   }
@@ -268,6 +261,11 @@ class SettingService extends ServiceBase {
           this._log(message, LOG_LEVEL_URGENT);
           throw new Error(message);
         }
+        if (settings.configPassphraseStore !== "") {
+          const message = `Failed to encrypt remote configuration '${id}'. Settings were not saved.`;
+          this._log(message, LOG_LEVEL_URGENT);
+          throw new Error(message);
+        }
         this._log(
           `Failed to encrypt remote configuration '${id}'. This entry will be saved in plain text.`,
           LOG_LEVEL_URGENT
@@ -496,34 +494,15 @@ class SettingService extends ServiceBase {
       }
     } else {
       if (settings.encryptedCouchDBConnection) {
-        const keys = [
-          "couchDB_URI",
-          "couchDB_USER",
-          "couchDB_PASSWORD",
-          "couchDB_DBNAME",
-          "accessKey",
-          "bucket",
-          "endpoint",
-          "region",
-          "secretKey"
-        ];
         const decrypted = this.tryDecodeJson(
           await this.decryptConfigurationItem(settings.encryptedCouchDBConnection, passphrase)
         );
-        if (decrypted) {
-          for (const key of keys) {
-            if (key in decrypted) {
-              settings[key] = decrypted[key];
-            }
-          }
-        } else {
+        if (!restoreConnectionSettings(settings, decrypted)) {
           this._log(
             "Failed to decrypt passphrase from data.json! Ensure configuration is correct before syncing with remote.",
             LOG_LEVEL_URGENT
           );
-          for (const key of keys) {
-            settings[key] = "";
-          }
+          clearConnectionSettings(settings);
         }
       }
       if (settings.encrypt && settings.encryptedPassphrase) {

package/dist/services/implements/injectable/InjectableSettingService.d.ts

@@ -1,11 +1,12 @@
 import type { ServiceContext } from "../../base/ServiceBase.js";
 import { SettingService, type SettingServiceDependencies } from "../../base/SettingService.js";
 import type { ObsidianLiveSyncSettings } from "../../../common/types.js";
+import type { PersistedSettings } from "../../../common/models/setting.policy.js";
 export declare class InjectableSettingService<T extends ServiceContext> extends SettingService<T> {
     constructor(context: T, dependencies: SettingServiceDependencies);
     protected setItem(key: string, value: string): void;
     protected getItem(key: string): string;
     protected deleteItem(key: string): void;
-    saveData: import("../../lib/HandlerUtils.js").HandlerFunction<(data: ObsidianLiveSyncSettings) => Promise<void>, unknown>;
+    saveData: import("../../lib/HandlerUtils.js").HandlerFunction<(data: PersistedSettings) => Promise<void>, unknown>;
     loadData: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<ObsidianLiveSyncSettings | undefined>, unknown>;
 }