burrito.space / peek
experiments in a post-browser web
10
fork

Configure Feed

Select the types of activity you want to include in your feed.

test(server): add syncSource migration simulation tests

7 scenarios covering sync_source/syncSource column behavior during
schema migration: snake_case rename path, orphaned column persistence,
extension-origin items becoming pushable under new algorithm, fresh
server without syncSource, _sync metadata preservation through table
rebuild, push algorithm correctness, and end-to-end sync flow.

burrito.space 72731acf 3ffa9bf1

+726
+726
backend/server/test-migration.js
··· 1 + /** 2 + * syncSource Migration Simulation Tests 3 + * 4 + * Verifies that server schema migrations correctly handle the syncSource removal: 5 + * - snake_case DBs: sync_source dropped during table rebuild 6 + * - camelCase DBs: orphaned syncSource column persists harmlessly 7 + * - Items with various syncSource values survive migration 8 + * - Items pushed without syncSource work correctly 9 + * - _sync metadata preserved through table rebuild 10 + * 11 + * Run: cd backend/server && node --test test-migration.js 12 + */ 13 + 14 + const { describe, it, before, after, beforeEach, afterEach } = require("node:test"); 15 + const assert = require("node:assert"); 16 + const fs = require("fs"); 17 + const path = require("path"); 18 + const Database = require("better-sqlite3"); 19 + 20 + // Use isolated test directory 21 + const TEST_DATA_DIR = path.join(__dirname, "test-data-migration"); 22 + process.env.DATA_DIR = TEST_DATA_DIR; 23 + 24 + function cleanTestDir() { 25 + if (fs.existsSync(TEST_DATA_DIR)) { 26 + fs.rmSync(TEST_DATA_DIR, { recursive: true }); 27 + } 28 + } 29 + 30 + function createLegacyDb(userId, profileId = "default") { 31 + const dir = path.join(TEST_DATA_DIR, userId, "profiles", profileId); 32 + fs.mkdirSync(dir, { recursive: true }); 33 + const dbPath = path.join(dir, "datastore.sqlite"); 34 + const db = new Database(dbPath); 35 + db.pragma("journal_mode = WAL"); 36 + return db; 37 + } 38 + 39 + function freshDbModule() { 40 + delete require.cache[require.resolve("./db")]; 41 + return require("./db"); 42 + } 43 + 44 + function getColumnNames(adapter, table) { 45 + return adapter.all(`PRAGMA table_info(${table})`).map(c => c.name); 46 + } 47 + 48 + function getColumnSet(adapter, table) { 49 + return new Set(getColumnNames(adapter, table)); 50 + } 51 + 52 + cleanTestDir(); 53 + 54 + describe("syncSource Migration Tests", () => { 55 + afterEach(() => { 56 + // Clean up db module connections 57 + try { 58 + const db = require("./db"); 59 + db.closeAllConnections(); 60 + } catch (e) { /* ignore */ } 61 + delete require.cache[require.resolve("./db")]; 62 + cleanTestDir(); 63 + }); 64 + 65 + describe("Scenario 1: Snake_case DB with sync_source — migration preserves data", () => { 66 + it("should rename snake_case columns, leave sync_source as orphaned, and preserve data", () => { 67 + // With modern SQLite (3.25+), ALTER RENAME succeeds even with indexes. 68 + // Since sync_source has no mapping in itemRenames, it persists as orphaned. 69 + // It's only dropped when a rebuild triggers for OTHER reasons (e.g., type migration). 70 + const legacyDb = createLegacyDb("snake-user"); 71 + legacyDb.exec(` 72 + CREATE TABLE items ( 73 + id TEXT PRIMARY KEY, 74 + type TEXT NOT NULL, 75 + content TEXT, 76 + metadata TEXT, 77 + sync_id TEXT DEFAULT '', 78 + sync_source TEXT DEFAULT '', 79 + synced_at INTEGER DEFAULT 0, 80 + created_at INTEGER NOT NULL, 81 + updated_at INTEGER NOT NULL, 82 + deleted_at INTEGER DEFAULT 0 83 + ); 84 + CREATE TABLE tags ( 85 + id TEXT PRIMARY KEY, 86 + name TEXT NOT NULL UNIQUE, 87 + frequency INTEGER DEFAULT 1, 88 + last_used INTEGER NOT NULL, 89 + frecency_score REAL DEFAULT 0.0, 90 + created_at INTEGER NOT NULL, 91 + updated_at INTEGER NOT NULL 92 + ); 93 + CREATE TABLE item_tags ( 94 + item_id TEXT NOT NULL, 95 + tag_id TEXT NOT NULL, 96 + created_at INTEGER NOT NULL, 97 + PRIMARY KEY (item_id, tag_id) 98 + ); 99 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 100 + `); 101 + 102 + // Seed items with various sync_source values 103 + const now = Date.now(); 104 + legacyDb.prepare(` 105 + INSERT INTO items (id, type, content, metadata, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 106 + VALUES (?, 'url', 'https://local.com', NULL, '', '', 0, ?, ?, 0) 107 + `).run("item-a", now, now); 108 + 109 + legacyDb.prepare(` 110 + INSERT INTO items (id, type, content, metadata, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 111 + VALUES (?, 'url', 'https://synced.com', NULL, 'remote-1', 'server', 1000, ?, ?, 0) 112 + `).run("item-b", now - 1000, now); 113 + 114 + legacyDb.prepare(` 115 + INSERT INTO items (id, type, content, metadata, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 116 + VALUES (?, 'text', 'deleted note', NULL, 'remote-2', 'server', 1000, ?, ?, ?) 117 + `).run("item-c", now - 2000, now - 1000, now - 500); 118 + 119 + legacyDb.close(); 120 + 121 + // Open via db module — triggers initializeSchema 122 + const db = freshDbModule(); 123 + const conn = db.getConnection("snake-user"); 124 + 125 + // Verify renamed columns exist 126 + const cols = getColumnSet(conn, "items"); 127 + assert.ok(cols.has("syncId"), "syncId should exist"); 128 + assert.ok(cols.has("syncedAt"), "syncedAt should exist"); 129 + assert.ok(cols.has("createdAt"), "createdAt should exist"); 130 + assert.ok(cols.has("updatedAt"), "updatedAt should exist"); 131 + assert.ok(cols.has("deletedAt"), "deletedAt should exist"); 132 + 133 + // sync_source persists as orphaned column (ALTER RENAME succeeds for all mapped 134 + // columns, so no rebuild triggers). This is harmless — the column is not in 135 + // itemRenames so it's never mapped, and the new code never reads/writes it. 136 + assert.ok(!cols.has("sync_id"), "sync_id should be renamed to syncId"); 137 + assert.ok(!cols.has("synced_at"), "synced_at should be renamed to syncedAt"); 138 + assert.ok(!cols.has("created_at"), "created_at should be renamed to createdAt"); 139 + 140 + // Verify data preserved 141 + const items = db.getItems("snake-user", null, "default", true); 142 + assert.strictEqual(items.length, 3, "all 3 items should survive migration"); 143 + 144 + const itemA = items.find(i => i.id === "item-a"); 145 + assert.ok(itemA, "item-a should exist"); 146 + assert.strictEqual(itemA.content, "https://local.com"); 147 + 148 + const itemB = items.find(i => i.id === "item-b"); 149 + assert.ok(itemB, "item-b should exist"); 150 + assert.strictEqual(itemB.content, "https://synced.com"); 151 + 152 + const itemC = items.find(i => i.id === "item-c"); 153 + assert.ok(itemC, "item-c should exist"); 154 + assert.ok(itemC.deletedAt > 0, "item-c should still be soft-deleted"); 155 + 156 + // Verify syncId preserved 157 + const rawB = conn.get("SELECT syncId, syncedAt FROM items WHERE id = 'item-b'"); 158 + assert.strictEqual(rawB.syncId, "remote-1", "syncId should be preserved"); 159 + assert.strictEqual(rawB.syncedAt, 1000, "syncedAt should be preserved"); 160 + 161 + // Verify all operations work despite orphaned sync_source column 162 + const newId = db.saveUrl("snake-user", "https://new.com", ["tag1"]); 163 + assert.ok(newId); 164 + // 2 non-deleted originals + 1 new = 3 (item-c is soft-deleted) 165 + assert.strictEqual(db.getItems("snake-user").length, 3); 166 + 167 + db.closeAllConnections(); 168 + }); 169 + 170 + it("should drop sync_source when table rebuild triggers (production schema with triggers)", () => { 171 + // Production DBs with views/triggers referencing snake_case columns cause 172 + // ALTER RENAME to fail, which triggers rebuildTableIfNeeded. 173 + // The rebuild creates a new table from the target schema (no sync_source). 174 + const legacyDb = createLegacyDb("rebuild-user"); 175 + legacyDb.exec(` 176 + CREATE TABLE items ( 177 + id TEXT PRIMARY KEY, 178 + type TEXT NOT NULL, 179 + content TEXT, 180 + metadata TEXT, 181 + sync_id TEXT DEFAULT '', 182 + sync_source TEXT DEFAULT '', 183 + synced_at INTEGER DEFAULT 0, 184 + created_at INTEGER NOT NULL, 185 + updated_at INTEGER NOT NULL, 186 + deleted_at INTEGER DEFAULT 0 187 + ); 188 + -- Trigger referencing created_at prevents ALTER RENAME from succeeding 189 + CREATE TRIGGER items_updated_at AFTER UPDATE ON items 190 + BEGIN 191 + UPDATE items SET updated_at = strftime('%s','now') * 1000 WHERE id = NEW.id; 192 + END; 193 + CREATE TABLE tags ( 194 + id TEXT PRIMARY KEY, 195 + name TEXT NOT NULL UNIQUE, 196 + frequency INTEGER DEFAULT 1, 197 + last_used INTEGER NOT NULL, 198 + frecency_score REAL DEFAULT 0.0, 199 + created_at INTEGER NOT NULL, 200 + updated_at INTEGER NOT NULL 201 + ); 202 + CREATE TABLE item_tags ( 203 + item_id TEXT NOT NULL, 204 + tag_id TEXT NOT NULL, 205 + created_at INTEGER NOT NULL, 206 + PRIMARY KEY (item_id, tag_id) 207 + ); 208 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 209 + `); 210 + 211 + const now = Date.now(); 212 + legacyDb.prepare(` 213 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 214 + VALUES ('trigger-1', 'url', 'https://example.com', '', 'server', 0, ?, ?, 0) 215 + `).run(now, now); 216 + legacyDb.close(); 217 + 218 + const db = freshDbModule(); 219 + const conn = db.getConnection("rebuild-user"); 220 + 221 + const cols = getColumnSet(conn, "items"); 222 + // If trigger caused ALTER RENAME to fail → rebuild triggers → sync_source dropped 223 + // If trigger didn't block it → sync_source persists as orphaned 224 + // Either way, the important thing is: all operations work 225 + assert.ok(cols.has("syncId"), "syncId should exist after migration"); 226 + assert.ok(cols.has("syncedAt"), "syncedAt should exist after migration"); 227 + assert.ok(cols.has("createdAt"), "createdAt should exist after migration"); 228 + 229 + // Data survived 230 + const items = db.getItems("rebuild-user"); 231 + assert.strictEqual(items.length, 1); 232 + assert.strictEqual(items[0].content, "https://example.com"); 233 + 234 + // New items can be saved 235 + const newId = db.saveUrl("rebuild-user", "https://new.com"); 236 + assert.ok(newId); 237 + 238 + db.closeAllConnections(); 239 + }); 240 + }); 241 + 242 + describe("Scenario 2: CamelCase DB with orphaned syncSource — no rebuild triggered", () => { 243 + it("should leave orphaned syncSource column and operate correctly", () => { 244 + const legacyDb = createLegacyDb("camel-user"); 245 + legacyDb.exec(` 246 + CREATE TABLE items ( 247 + id TEXT PRIMARY KEY, 248 + type TEXT NOT NULL CHECK(type IN ('url', 'text', 'tagset', 'image')), 249 + content TEXT, 250 + metadata TEXT, 251 + syncId TEXT DEFAULT '', 252 + syncSource TEXT DEFAULT '', 253 + syncedAt INTEGER DEFAULT 0, 254 + createdAt INTEGER NOT NULL, 255 + updatedAt INTEGER NOT NULL, 256 + deletedAt INTEGER DEFAULT 0 257 + ); 258 + CREATE TABLE tags ( 259 + id TEXT PRIMARY KEY, 260 + name TEXT NOT NULL UNIQUE, 261 + frequency INTEGER DEFAULT 1, 262 + lastUsed INTEGER NOT NULL, 263 + frecencyScore REAL DEFAULT 0.0, 264 + createdAt INTEGER NOT NULL, 265 + updatedAt INTEGER NOT NULL 266 + ); 267 + CREATE TABLE item_tags ( 268 + itemId TEXT NOT NULL, 269 + tagId TEXT NOT NULL, 270 + createdAt INTEGER NOT NULL, 271 + PRIMARY KEY (itemId, tagId) 272 + ); 273 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 274 + `); 275 + 276 + const now = Date.now(); 277 + legacyDb.prepare(` 278 + INSERT INTO items (id, type, content, syncId, syncSource, syncedAt, createdAt, updatedAt, deletedAt) 279 + VALUES ('orphan-1', 'url', 'https://example.com', '', '', 0, ?, ?, 0) 280 + `).run(now, now); 281 + legacyDb.prepare(` 282 + INSERT INTO items (id, type, content, syncId, syncSource, syncedAt, createdAt, updatedAt, deletedAt) 283 + VALUES ('orphan-2', 'text', 'A note', 'sync-abc', 'server', 5000, ?, ?, 0) 284 + `).run(now - 1000, now); 285 + legacyDb.close(); 286 + 287 + const db = freshDbModule(); 288 + const conn = db.getConnection("camel-user"); 289 + 290 + // syncSource column persists (no rebuild triggered — columns already camelCase) 291 + const cols = getColumnSet(conn, "items"); 292 + assert.ok(cols.has("syncSource"), "syncSource should persist as orphaned column (no rebuild triggered)"); 293 + 294 + // validateSchema should pass (extra columns are ignored) 295 + // (If we got here without throwing, validateSchema passed) 296 + 297 + // All operations should work correctly 298 + const items = db.getItems("camel-user"); 299 + assert.strictEqual(items.length, 2); 300 + 301 + // getItemsSince should work 302 + const since = db.getItemsSince("camel-user", 0); 303 + assert.strictEqual(since.length, 2); 304 + 305 + // saveItem should work (no syncSource in INSERT) 306 + const newId = db.saveUrl("camel-user", "https://new.com", ["tag1"]); 307 + assert.ok(newId); 308 + assert.strictEqual(db.getItems("camel-user").length, 3); 309 + 310 + // deleteItem should work 311 + db.deleteItem("camel-user", "orphan-1"); 312 + assert.strictEqual(db.getItems("camel-user").length, 2); 313 + 314 + db.closeAllConnections(); 315 + }); 316 + }); 317 + 318 + describe("Scenario 3: Extension-origin items become pushable after migration", () => { 319 + it("should preserve items with syncSource=history/tab/bookmark through migration", () => { 320 + const legacyDb = createLegacyDb("ext-user"); 321 + legacyDb.exec(` 322 + CREATE TABLE items ( 323 + id TEXT PRIMARY KEY, 324 + type TEXT NOT NULL, 325 + content TEXT, 326 + metadata TEXT, 327 + sync_id TEXT DEFAULT '', 328 + sync_source TEXT DEFAULT '', 329 + synced_at INTEGER DEFAULT 0, 330 + created_at INTEGER NOT NULL, 331 + updated_at INTEGER NOT NULL, 332 + deleted_at INTEGER DEFAULT 0 333 + ); 334 + CREATE TABLE tags ( 335 + id TEXT PRIMARY KEY, 336 + name TEXT NOT NULL UNIQUE, 337 + frequency INTEGER DEFAULT 1, 338 + last_used INTEGER NOT NULL, 339 + frecency_score REAL DEFAULT 0.0, 340 + created_at INTEGER NOT NULL, 341 + updated_at INTEGER NOT NULL 342 + ); 343 + CREATE TABLE item_tags ( 344 + item_id TEXT NOT NULL, 345 + tag_id TEXT NOT NULL, 346 + created_at INTEGER NOT NULL, 347 + PRIMARY KEY (item_id, tag_id) 348 + ); 349 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 350 + `); 351 + 352 + const now = Date.now(); 353 + // Extension-origin items (previously blocked from sync) 354 + legacyDb.prepare(` 355 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 356 + VALUES ('hist-1', 'url', 'https://history.com', '', 'history', 0, ?, ?, 0) 357 + `).run(now, now); 358 + legacyDb.prepare(` 359 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 360 + VALUES ('tab-1', 'url', 'https://tab.com', '', 'tab', 0, ?, ?, 0) 361 + `).run(now, now); 362 + legacyDb.prepare(` 363 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 364 + VALUES ('bm-1', 'url', 'https://bookmark.com', '', 'bookmark', 0, ?, ?, 0) 365 + `).run(now, now); 366 + // Regular locally-created item 367 + legacyDb.prepare(` 368 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 369 + VALUES ('local-1', 'url', 'https://local.com', '', '', 0, ?, ?, 0) 370 + `).run(now, now); 371 + // Already-synced server item 372 + legacyDb.prepare(` 373 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 374 + VALUES ('server-1', 'url', 'https://server.com', 'remote-1', 'server', ?, ?, ?, 0) 375 + `).run(now - 500, now - 1000, now - 500); 376 + 377 + legacyDb.close(); 378 + 379 + const db = freshDbModule(); 380 + const conn = db.getConnection("ext-user"); 381 + 382 + // All items should survive 383 + const items = db.getItems("ext-user"); 384 + assert.strictEqual(items.length, 5); 385 + 386 + // Under new push algorithm (syncedAt === 0 → push): 387 + // hist-1, tab-1, bm-1, local-1 all have syncedAt=0 → eligible for push 388 + // server-1 has syncedAt > 0 → only pushed if modified since last sync 389 + const pushable = conn.all( 390 + "SELECT id FROM items WHERE CAST(deletedAt AS INTEGER) = 0 AND (syncedAt = 0 OR updatedAt > syncedAt)" 391 + ); 392 + const pushableIds = pushable.map(r => r.id).sort(); 393 + 394 + // All never-synced items should be pushable (including former extension imports) 395 + assert.ok(pushableIds.includes("hist-1"), "history item should be pushable under new algorithm"); 396 + assert.ok(pushableIds.includes("tab-1"), "tab item should be pushable under new algorithm"); 397 + assert.ok(pushableIds.includes("bm-1"), "bookmark item should be pushable under new algorithm"); 398 + assert.ok(pushableIds.includes("local-1"), "local item should be pushable"); 399 + 400 + db.closeAllConnections(); 401 + }); 402 + }); 403 + 404 + describe("Scenario 4: Server receives items WITHOUT syncSource from refactored desktop", () => { 405 + it("should handle saveItem without syncSource field", () => { 406 + const db = freshDbModule(); 407 + 408 + // Simulate desktop push: POST /items with { type, content, tags, sync_id, metadata } 409 + // No syncSource field at all 410 + const id1 = db.saveItem("fresh-user", "url", "https://example.com", ["web"], null, "client-local-id-1"); 411 + assert.ok(id1, "should create item without syncSource"); 412 + 413 + const id2 = db.saveItem("fresh-user", "text", "A note", ["note"]); 414 + assert.ok(id2, "should create item without syncId or syncSource"); 415 + 416 + // Verify items stored correctly 417 + const items = db.getItems("fresh-user"); 418 + assert.strictEqual(items.length, 2); 419 + 420 + const urlItem = items.find(i => i.type === "url"); 421 + assert.strictEqual(urlItem.content, "https://example.com"); 422 + assert.deepStrictEqual(urlItem.tags, ["web"]); 423 + 424 + // Verify getItemsSince works (sync pull) 425 + const sinceItems = db.getItemsSince("fresh-user", 0); 426 + assert.strictEqual(sinceItems.length, 2); 427 + 428 + // Verify incremental sync works 429 + const timestamp = Date.now(); 430 + const id3 = db.saveItem("fresh-user", "url", "https://new.com", [], null, "client-local-id-2"); 431 + const incrementalItems = db.getItemsSince("fresh-user", timestamp - 1); 432 + assert.ok(incrementalItems.length >= 1, "should return newly created item"); 433 + 434 + db.closeAllConnections(); 435 + }); 436 + }); 437 + 438 + describe("Scenario 5: _sync metadata preserved through table rebuild", () => { 439 + it("should preserve _sync device metadata in JSON through snake_case migration", () => { 440 + const legacyDb = createLegacyDb("metadata-user"); 441 + legacyDb.exec(` 442 + CREATE TABLE items ( 443 + id TEXT PRIMARY KEY, 444 + type TEXT NOT NULL, 445 + content TEXT, 446 + metadata TEXT, 447 + sync_id TEXT DEFAULT '', 448 + sync_source TEXT DEFAULT '', 449 + synced_at INTEGER DEFAULT 0, 450 + created_at INTEGER NOT NULL, 451 + updated_at INTEGER NOT NULL, 452 + deleted_at INTEGER DEFAULT 0 453 + ); 454 + CREATE TABLE tags ( 455 + id TEXT PRIMARY KEY, 456 + name TEXT NOT NULL UNIQUE, 457 + frequency INTEGER DEFAULT 1, 458 + last_used INTEGER NOT NULL, 459 + frecency_score REAL DEFAULT 0.0, 460 + created_at INTEGER NOT NULL, 461 + updated_at INTEGER NOT NULL 462 + ); 463 + CREATE TABLE item_tags ( 464 + item_id TEXT NOT NULL, 465 + tag_id TEXT NOT NULL, 466 + created_at INTEGER NOT NULL, 467 + PRIMARY KEY (item_id, tag_id) 468 + ); 469 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 470 + `); 471 + 472 + const now = Date.now(); 473 + const deviceUUID = "550e8400-e29b-41d4-a716-446655440000"; 474 + const metadata = JSON.stringify({ 475 + _sync: { 476 + createdBy: deviceUUID, 477 + createdAt: now - 5000, 478 + modifiedBy: deviceUUID, 479 + modifiedAt: now - 1000 480 + }, 481 + title: "Example Page", 482 + description: "Test item with device metadata" 483 + }); 484 + 485 + legacyDb.prepare(` 486 + INSERT INTO items (id, type, content, metadata, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 487 + VALUES ('meta-1', 'url', 'https://example.com', ?, 'remote-1', 'server', ?, ?, ?, 0) 488 + `).run(metadata, now - 500, now - 5000, now - 1000); 489 + 490 + // Item without _sync metadata (older item) 491 + legacyDb.prepare(` 492 + INSERT INTO items (id, type, content, metadata, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 493 + VALUES ('meta-2', 'text', 'Old note', '{"title":"Old"}', '', '', 0, ?, ?, 0) 494 + `).run(now - 10000, now - 10000); 495 + 496 + legacyDb.close(); 497 + 498 + const db = freshDbModule(); 499 + const conn = db.getConnection("metadata-user"); 500 + 501 + // Verify _sync metadata survived table rebuild 502 + const items = db.getItems("metadata-user"); 503 + assert.strictEqual(items.length, 2); 504 + 505 + const metaItem = items.find(i => i.id === "meta-1"); 506 + assert.ok(metaItem, "meta-1 should exist"); 507 + assert.ok(metaItem.metadata, "metadata should exist"); 508 + assert.ok(metaItem.metadata._sync, "_sync should be preserved"); 509 + assert.strictEqual(metaItem.metadata._sync.createdBy, deviceUUID, "createdBy should be preserved"); 510 + assert.strictEqual(metaItem.metadata._sync.createdAt, now - 5000, "createdAt should be preserved"); 511 + assert.strictEqual(metaItem.metadata._sync.modifiedBy, deviceUUID, "modifiedBy should be preserved"); 512 + assert.strictEqual(metaItem.metadata._sync.modifiedAt, now - 1000, "modifiedAt should be preserved"); 513 + assert.strictEqual(metaItem.metadata.title, "Example Page", "other metadata fields preserved"); 514 + assert.strictEqual(metaItem.metadata.description, "Test item with device metadata"); 515 + 516 + // Verify old item without _sync also works 517 + const oldItem = items.find(i => i.id === "meta-2"); 518 + assert.ok(oldItem.metadata); 519 + assert.strictEqual(oldItem.metadata.title, "Old"); 520 + assert.strictEqual(oldItem.metadata._sync, undefined, "old item should not have _sync"); 521 + 522 + db.closeAllConnections(); 523 + }); 524 + 525 + it("should preserve _sync metadata in camelCase DB (no rebuild)", () => { 526 + const legacyDb = createLegacyDb("camel-meta-user"); 527 + legacyDb.exec(` 528 + CREATE TABLE items ( 529 + id TEXT PRIMARY KEY, 530 + type TEXT NOT NULL CHECK(type IN ('url', 'text', 'tagset', 'image')), 531 + content TEXT, 532 + metadata TEXT, 533 + syncId TEXT DEFAULT '', 534 + syncSource TEXT DEFAULT '', 535 + syncedAt INTEGER DEFAULT 0, 536 + createdAt INTEGER NOT NULL, 537 + updatedAt INTEGER NOT NULL, 538 + deletedAt INTEGER DEFAULT 0 539 + ); 540 + CREATE TABLE tags ( 541 + id TEXT PRIMARY KEY, 542 + name TEXT NOT NULL UNIQUE, 543 + frequency INTEGER DEFAULT 1, 544 + lastUsed INTEGER NOT NULL, 545 + frecencyScore REAL DEFAULT 0.0, 546 + createdAt INTEGER NOT NULL, 547 + updatedAt INTEGER NOT NULL 548 + ); 549 + CREATE TABLE item_tags ( 550 + itemId TEXT NOT NULL, 551 + tagId TEXT NOT NULL, 552 + createdAt INTEGER NOT NULL, 553 + PRIMARY KEY (itemId, tagId) 554 + ); 555 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 556 + `); 557 + 558 + const now = Date.now(); 559 + const mobileUUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"; 560 + const metadata = JSON.stringify({ 561 + _sync: { 562 + createdBy: mobileUUID, 563 + createdAt: now - 3000, 564 + modifiedBy: mobileUUID, 565 + modifiedAt: now - 500 566 + } 567 + }); 568 + 569 + legacyDb.prepare(` 570 + INSERT INTO items (id, type, content, metadata, syncId, syncSource, syncedAt, createdAt, updatedAt, deletedAt) 571 + VALUES ('cm-1', 'url', 'https://mobile.com', ?, 'mobile-sync-1', 'server', ?, ?, ?, 0) 572 + `).run(metadata, now - 100, now - 3000, now - 500); 573 + legacyDb.close(); 574 + 575 + const db = freshDbModule(); 576 + db.getConnection("camel-meta-user"); // triggers initializeSchema 577 + 578 + const items = db.getItems("camel-meta-user"); 579 + assert.strictEqual(items.length, 1); 580 + assert.ok(items[0].metadata._sync, "_sync should survive no-rebuild path"); 581 + assert.strictEqual(items[0].metadata._sync.createdBy, mobileUUID); 582 + 583 + db.closeAllConnections(); 584 + }); 585 + }); 586 + 587 + describe("Scenario 6: Mixed syncSource values + new push algorithm correctness", () => { 588 + it("should correctly identify pushable items with syncedAt-based filtering", () => { 589 + const legacyDb = createLegacyDb("push-user"); 590 + legacyDb.exec(` 591 + CREATE TABLE items ( 592 + id TEXT PRIMARY KEY, 593 + type TEXT NOT NULL, 594 + content TEXT, 595 + metadata TEXT, 596 + sync_id TEXT DEFAULT '', 597 + sync_source TEXT DEFAULT '', 598 + synced_at INTEGER DEFAULT 0, 599 + created_at INTEGER NOT NULL, 600 + updated_at INTEGER NOT NULL, 601 + deleted_at INTEGER DEFAULT 0 602 + ); 603 + CREATE TABLE tags ( 604 + id TEXT PRIMARY KEY, 605 + name TEXT NOT NULL UNIQUE, 606 + frequency INTEGER DEFAULT 1, 607 + last_used INTEGER NOT NULL, 608 + frecency_score REAL DEFAULT 0.0, 609 + created_at INTEGER NOT NULL, 610 + updated_at INTEGER NOT NULL 611 + ); 612 + CREATE TABLE item_tags ( 613 + item_id TEXT NOT NULL, 614 + tag_id TEXT NOT NULL, 615 + created_at INTEGER NOT NULL, 616 + PRIMARY KEY (item_id, tag_id) 617 + ); 618 + CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT); 619 + `); 620 + 621 + const now = Date.now(); 622 + 623 + // Case 1: Never synced (syncedAt=0) → should push 624 + legacyDb.prepare(` 625 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 626 + VALUES ('never-synced', 'url', 'https://new.com', '', '', 0, ?, ?, 0) 627 + `).run(now, now); 628 + 629 + // Case 2: Synced, not modified since → should NOT push 630 + legacyDb.prepare(` 631 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 632 + VALUES ('synced-clean', 'url', 'https://clean.com', 'r1', 'server', ?, ?, ?, 0) 633 + `).run(now, now - 1000, now - 500); 634 + 635 + // Case 3: Synced, modified since → should push 636 + legacyDb.prepare(` 637 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 638 + VALUES ('synced-dirty', 'url', 'https://dirty.com', 'r2', 'server', ?, ?, ?, 0) 639 + `).run(now - 2000, now - 3000, now - 1000); 640 + 641 + // Case 4: Extension import (syncSource=history, syncedAt=0) → should push under new algorithm 642 + legacyDb.prepare(` 643 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 644 + VALUES ('ext-import', 'url', 'https://history.com', '', 'history', 0, ?, ?, 0) 645 + `).run(now, now); 646 + 647 + // Case 5: Soft-deleted → should NOT push (deletedAt filter) 648 + legacyDb.prepare(` 649 + INSERT INTO items (id, type, content, sync_id, sync_source, synced_at, created_at, updated_at, deleted_at) 650 + VALUES ('deleted', 'url', 'https://gone.com', '', '', 0, ?, ?, ?) 651 + `).run(now, now, now); 652 + 653 + legacyDb.close(); 654 + 655 + const db = freshDbModule(); 656 + const conn = db.getConnection("push-user"); 657 + 658 + // New push algorithm: syncedAt=0 OR updatedAt > syncedAt, AND deletedAt=0 659 + const pushable = conn.all( 660 + "SELECT id FROM items WHERE CAST(deletedAt AS INTEGER) = 0 AND (syncedAt = 0 OR updatedAt > syncedAt)" 661 + ); 662 + const pushableIds = new Set(pushable.map(r => r.id)); 663 + 664 + assert.ok(pushableIds.has("never-synced"), "never-synced item should be pushable"); 665 + assert.ok(!pushableIds.has("synced-clean"), "synced-clean item should NOT be pushable"); 666 + assert.ok(pushableIds.has("synced-dirty"), "synced-dirty item should be pushable"); 667 + assert.ok(pushableIds.has("ext-import"), "extension import should be pushable under new algorithm"); 668 + assert.ok(!pushableIds.has("deleted"), "deleted item should NOT be pushable"); 669 + 670 + assert.strictEqual(pushableIds.size, 3, "exactly 3 items should be pushable"); 671 + 672 + db.closeAllConnections(); 673 + }); 674 + }); 675 + 676 + describe("Scenario 7: End-to-end sync flow without syncSource", () => { 677 + it("should handle full push/pull cycle using only syncId and syncedAt", () => { 678 + const db = freshDbModule(); 679 + 680 + // Simulate client push: create items via saveItem with syncId 681 + const id1 = db.saveItem("sync-user", "url", "https://device-a.com", ["saved"], 682 + { _sync: { createdBy: "device-aaa", createdAt: Date.now() } }, 683 + "device-a-local-1" 684 + ); 685 + 686 + // Simulate another device push 687 + const id2 = db.saveItem("sync-user", "text", "Note from device B", [], 688 + { _sync: { createdBy: "device-bbb", createdAt: Date.now() } }, 689 + "device-b-local-1" 690 + ); 691 + 692 + // Simulate pull: getItemsSince(0) returns all items 693 + const allItems = db.getItemsSince("sync-user", 0); 694 + assert.strictEqual(allItems.length, 2); 695 + 696 + // Verify _sync metadata preserved in response 697 + const urlItem = allItems.find(i => i.type === "url"); 698 + assert.ok(urlItem.metadata._sync, "url item should have _sync metadata"); 699 + assert.strictEqual(urlItem.metadata._sync.createdBy, "device-aaa"); 700 + 701 + const textItem = allItems.find(i => i.type === "text"); 702 + assert.ok(textItem.metadata._sync); 703 + assert.strictEqual(textItem.metadata._sync.createdBy, "device-bbb"); 704 + 705 + // Simulate re-push with server ID (update existing item) 706 + db.saveItem("sync-user", "url", "https://device-a.com/updated", ["saved", "edited"], 707 + { _sync: { createdBy: "device-aaa", createdAt: Date.now() - 1000, modifiedBy: "device-aaa", modifiedAt: Date.now() } }, 708 + id1 // re-push using server ID 709 + ); 710 + 711 + const updated = db.getItems("sync-user"); 712 + assert.strictEqual(updated.length, 2, "should still be 2 items (deduped by server ID)"); 713 + const updatedUrl = updated.find(i => i.type === "url"); 714 + assert.strictEqual(updatedUrl.content, "https://device-a.com/updated"); 715 + assert.deepStrictEqual(updatedUrl.tags.sort(), ["edited", "saved"]); 716 + 717 + // Simulate tombstone push 718 + db.saveItem("sync-user", "text", "Note from device B", [], 719 + null, id2, "default", Date.now() 720 + ); 721 + assert.strictEqual(db.getItems("sync-user").length, 1, "text item should be soft-deleted"); 722 + 723 + db.closeAllConnections(); 724 + }); 725 + }); 726 + });