mirror of
https://github.com/vrtmrz/obsidian-livesync.git
synced 2026-09-27 04:57:06 +00:00
219 lines
12 KiB
TypeScript
219 lines
12 KiB
TypeScript
import { evalObsidianJson } from "../runner/cli.ts";
|
|
import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
|
|
import {
|
|
assertEqual,
|
|
createE2eObsidianDeviceLocalState,
|
|
waitForLiveSyncCoreReady,
|
|
waitForLocalDatabaseEntry,
|
|
} from "../runner/liveSyncWorkflow.ts";
|
|
import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
|
|
import { createTemporaryVault } from "../runner/vault.ts";
|
|
|
|
const paths = ["stale-known.md", "stale-unknown.md"];
|
|
const recoveredPath = "stale-recovered.md";
|
|
const oldContent = "# Note\nKeep\n\nTail\n\nFooter\n";
|
|
const newContent = oldContent.replace(
|
|
"Footer\n",
|
|
Array.from({ length: 50 }, (_, index) => `Remote addition ${index}\n`).join("") + "Footer\n"
|
|
);
|
|
|
|
type Branch = { rev: string; content: string; history: string[] };
|
|
type FileState = { path: string; content: string; rev: string; branches: Branch[]; provenance: string | null };
|
|
|
|
async function readState(cliBinary: string, env: NodeJS.ProcessEnv): Promise<FileState[]> {
|
|
return await evalObsidianJson<FileState[]>(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
const store=core.services.keyValueDB.openSimpleStore('file-reflection-provenance-v1');
|
|
const states=[];
|
|
for(const path of ${JSON.stringify([...paths, recoveredPath])}){
|
|
const meta=await core.localDatabase.getDBEntryMeta(path,{conflicts:true},true);
|
|
const branches=[];
|
|
for(const rev of [meta._rev,...(meta._conflicts??[])]){
|
|
const entry=await core.localDatabase.getDBEntry(path,{rev,revs:true},false,true,true);
|
|
const raw=await core.localDatabase.getRaw(meta._id,{rev,revs:true});
|
|
branches.push({rev,content:Array.isArray(entry.data)?entry.data.join(''):entry.data,
|
|
history:raw._revisions.ids.map((id,i)=>(raw._revisions.start-i)+'-'+id)});
|
|
}
|
|
const file=app.vault.getAbstractFileByPath(path);
|
|
states.push({path,content:await app.vault.read(file),rev:meta._rev,branches,
|
|
provenance:(await store.get(path))?.revision??null});
|
|
}
|
|
return JSON.stringify(states);
|
|
})()`,
|
|
env
|
|
);
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
const binary = requireObsidianBinary();
|
|
const cli = discoverObsidianCli();
|
|
if (!cli.binary) throw new Error(`Could not find obsidian-cli. Checked: ${cli.checked.join(", ")}`);
|
|
const cliBinary = cli.binary;
|
|
const vault = await createTemporaryVault("obsidian-livesync-stale-file-");
|
|
let session: ObsidianLiveSyncSession | undefined;
|
|
try {
|
|
session = await startObsidianLiveSyncSession({
|
|
binary,
|
|
cliBinary,
|
|
vault,
|
|
pluginData: {
|
|
doctorProcessedVersion: "1.0.0",
|
|
isConfigured: true,
|
|
liveSync: false,
|
|
remoteType: "",
|
|
couchDB_URI: "http://127.0.0.1:5984",
|
|
couchDB_DBNAME: "stale-file-restart",
|
|
notifyThresholdOfRemoteStorageSize: -1,
|
|
periodicReplication: false,
|
|
syncAfterMerge: false,
|
|
syncOnEditorSave: false,
|
|
syncOnFileOpen: false,
|
|
syncOnSave: false,
|
|
syncOnStart: false,
|
|
disableMarkdownAutoMerge: false,
|
|
resolveConflictsByNewerFile: false,
|
|
checkConflictOnlyOnOpen: true,
|
|
showMergeDialogOnlyOnActive: true,
|
|
},
|
|
localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
|
|
});
|
|
await waitForLiveSyncCoreReady(cliBinary, session.cliEnv);
|
|
await evalObsidianJson(
|
|
cliBinary,
|
|
`(async()=>{
|
|
for(const path of ${JSON.stringify([...paths, recoveredPath])}) await app.vault.create(path,${JSON.stringify(oldContent)});
|
|
return JSON.stringify(true);
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
for (const path of [...paths, recoveredPath]) await waitForLocalDatabaseEntry(cliBinary, session.cliEnv, path);
|
|
|
|
// Drain real Vault events before creating a persisted pending-event fixture.
|
|
// The DB advances without reflecting it in the Vault, as on an offline device.
|
|
const fixture = await evalObsidianJson<{ current: string[]; original: string[]; recovered: string }>(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
const store=core.services.keyValueDB.openSimpleStore('file-reflection-provenance-v1');
|
|
await core.services.fileProcessing.commitPendingFileEvents();
|
|
const snapshot=[], current=[], original=[];
|
|
for(const [index,path] of ${JSON.stringify(paths)}.entries()){
|
|
const meta=await core.localDatabase.getDBEntryMeta(path,{},true);
|
|
const file=await core.storageAccess.getFileStub(path);
|
|
const data=new Blob([${JSON.stringify(newContent)}],{type:'text/plain'});
|
|
const result=await core.localDatabase.putDBEntry({...meta,data,mtime:file.stat.mtime+60000,
|
|
size:data.size,children:[]},false,meta._rev);
|
|
if(!result?.ok) throw new Error('Could not advance '+path);
|
|
current.push(result.rev); original.push(meta._rev);
|
|
if(index===0) await store.set(path,{revision:meta._rev,observedStorageMtime:file.stat.mtime});
|
|
else await store.delete(path);
|
|
snapshot.push({type:'CHANGED',key:'CHANGED-'+path,args:{file}});
|
|
}
|
|
const recovered=${JSON.stringify(recoveredPath)};
|
|
const recoveredMeta=await core.localDatabase.getDBEntryMeta(recovered,{},true);
|
|
await store.delete(recovered);
|
|
await core.kvDB.set('storage-event-manager-snapshot',snapshot);
|
|
return JSON.stringify({current,original,recovered:recoveredMeta._rev});
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
await session.app.stop();
|
|
session = undefined;
|
|
|
|
session = await startObsidianLiveSyncSession({ binary, cliBinary, vault });
|
|
await waitForLiveSyncCoreReady(cliBinary, session.cliEnv);
|
|
const [known, unknown, recovered] = await readState(cliBinary, session.cliEnv);
|
|
assertEqual(known.rev, fixture.current[0], "An unchanged stale file created a revision during restart.");
|
|
assertEqual(known.branches.length, 1, "An unchanged stale file created a conflict.");
|
|
assertEqual(known.content, newContent, "The newer DB content was not reflected after suppressing the save.");
|
|
assertEqual(known.provenance, fixture.current[0], "The reflected revision was not recorded.");
|
|
assertEqual(unknown.branches.length, 2, "Unknown local content was not preserved as a conflict.");
|
|
assertEqual(unknown.content, oldContent, "Unknown local content was overwritten.");
|
|
const independent = unknown.branches.find((branch) => branch.content === oldContent);
|
|
if (!independent) throw new Error("The old local content is missing from the current branches.");
|
|
assertEqual(independent.history.length, 1, "Unknown content was attached to an inferred ancestor.");
|
|
if (independent.rev === fixture.original[1]) throw new Error("The historical root was reused.");
|
|
if (!unknown.branches.some((branch) => branch.content === newContent)) {
|
|
throw new Error("The remote additions were lost.");
|
|
}
|
|
assertEqual(recovered.rev, fixture.recovered, "Unchanged recovery added a database revision.");
|
|
assertEqual(recovered.branches.length, 1, "Unchanged recovery created a conflict.");
|
|
assertEqual(recovered.content, oldContent, "Unchanged recovery modified the Vault file.");
|
|
assertEqual(recovered.provenance, fixture.recovered, "Start-up did not recover missing file provenance.");
|
|
|
|
const receivedRevision = await evalObsidianJson<string>(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
const path=${JSON.stringify(recoveredPath)};
|
|
const meta=await core.localDatabase.getDBEntryMeta(path,{},true);
|
|
const file=await core.storageAccess.getFileStub(path);
|
|
const data=new Blob([${JSON.stringify(newContent)}],{type:'text/plain'});
|
|
const result=await core.localDatabase.putDBEntry({...meta,data,mtime:file.stat.mtime+60000,
|
|
size:data.size,children:[]},false,meta._rev);
|
|
if(!result?.ok) throw new Error('Could not advance '+path);
|
|
if(!await core.fileHandler.dbToStorage(path,path,false)) throw new Error('Could not reflect '+path);
|
|
return JSON.stringify(result.rev);
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
const [, , received] = await readState(cliBinary, session.cliEnv);
|
|
assertEqual(received.rev, receivedRevision, "Incoming revision was not retained.");
|
|
assertEqual(received.branches.length, 1, "Incoming revision created a conflict after recovery.");
|
|
assertEqual(received.content, newContent, "Incoming revision was not reflected after recovery.");
|
|
assertEqual(received.provenance, receivedRevision, "Incoming reflection did not record its revision.");
|
|
|
|
await evalObsidianJson(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
const path=${JSON.stringify(paths[1])};
|
|
await core.services.keyValueDB.openSimpleStore('file-reflection-provenance-v1').delete(path);
|
|
if(!await core.fileHandler.storeFileToDB(path)) throw new Error('Repeated save failed');
|
|
await app.workspace.getLeaf(false).openFile(app.vault.getAbstractFileByPath(${JSON.stringify(paths[0])}));
|
|
await core.services.conflict.resolve(path);
|
|
return JSON.stringify(true);
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
const [, repeated] = await readState(cliBinary, session.cliEnv);
|
|
assertEqual(
|
|
repeated.branches
|
|
.map((branch) => branch.rev)
|
|
.sort()
|
|
.join(","),
|
|
unknown.branches
|
|
.map((branch) => branch.rev)
|
|
.sort()
|
|
.join(","),
|
|
"Losing provenance and reprocessing added or auto-merged a branch."
|
|
);
|
|
await evalObsidianJson(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
core.settings.resolveConflictsByNewerFile=true;
|
|
await core.services.conflict.resolve(${JSON.stringify(paths[1])});
|
|
return JSON.stringify(true);
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
const [, resolved] = await readState(cliBinary, session.cliEnv);
|
|
assertEqual(resolved.branches.length, 1, "The explicit newer-file option did not resolve the conflict.");
|
|
assertEqual(resolved.content, newContent, "The newer-file option did not reflect the newer DB version.");
|
|
console.log(
|
|
"Stale-file restart: missing unchanged provenance recovered; later update reflected; unknown content preserved; explicit newer-file resolution retained."
|
|
);
|
|
} finally {
|
|
if (session) await session.app.stop();
|
|
await vault.dispose();
|
|
}
|
|
}
|
|
|
|
main().catch((error: unknown) => {
|
|
console.error(error instanceof Error ? error.stack : error);
|
|
process.exitCode = 1;
|
|
});
|