@gamflaz/opencode-todolist 1.0.12 → 1.1.1

package/dist/storage/migrate-json.js

@@ -0,0 +1,278 @@
+import { readFileSync, readdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { asc, eq } from "drizzle-orm";
+import { TodoListSchema } from "../schemas/todo.js";
+import { InvalidTodoDataError } from "./errors.js";
+import { todoItem, todoSession } from "./schema.js";
+const FILE_PREFIX = "todos-";
+const FILE_SUFFIX = ".json";
+const MIGRATED_SUFFIX = ".json.migrated";
+/** `todos-<ts>.json` holds the payload; `version` holds the counter. */
+export function readLegacyVersion(sessionDir) {
+    for (const candidate of [
+        join(sessionDir, "version"),
+        join(sessionDir, "todos", "version"),
+    ]) {
+        try {
+            const value = Number.parseInt(readFileSync(candidate, "utf8").trim(), 10);
+            if (Number.isSafeInteger(value) && value >= 0)
+                return value;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return 0;
+}
+/** Newest payload file wins, matching the old "latest wins" behaviour. */
+export function findLegacyTodoFile(sessionDir) {
+    for (const dir of [join(sessionDir, "todos"), sessionDir]) {
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        const newest = names
+            .filter((name) => name.startsWith(FILE_PREFIX) && name.endsWith(FILE_SUFFIX))
+            .map((name) => ({
+            path: join(dir, name),
+            timestamp: Number(name.slice(FILE_PREFIX.length, -FILE_SUFFIX.length)),
+        }))
+            .filter((entry) => Number.isSafeInteger(entry.timestamp) && entry.timestamp >= 0)
+            .sort((left, right) => right.timestamp - left.timestamp)[0];
+        if (newest)
+            return newest.path;
+    }
+    return undefined;
+}
+/** Parses a legacy payload, accepting the wrapped object and the bare array. */
+export function parseLegacyTodos(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const list = Array.isArray(parsed)
+        ? parsed
+        : typeof parsed === "object" && parsed !== null && "todos" in parsed
+            ? parsed.todos
+            : undefined;
+    if (!Array.isArray(list)) {
+        throw new InvalidTodoDataError("[todo store read failed] invalid todo data: todo list is missing");
+    }
+    const result = TodoListSchema.safeParse(list);
+    if (!result.success) {
+        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${result.error.issues
+            .map((issue) => issue.message)
+            .join(", ")}`);
+    }
+    return result.data;
+}
+/**
+ * Replaces a session's whole list in one transaction.
+ *
+ * Used by both the importer and every normal write, so ordering (`position`)
+ * and atomicity are identical everywhere.
+ *
+ * `behavior: "immediate"` takes the write lock before reading, so two
+ * processes cannot both observe an old revision and then write rows that
+ * conflict. Combined with `busy_timeout` the second writer waits instead of
+ * failing.
+ */
+export function replaceSessionTodos(handle, sessionKey, todos) {
+    return handle.db.transaction((tx) => writeSessionTodos(tx, sessionKey, todos), { behavior: "immediate" });
+}
+/** Reads a session's revision, or 0 when the session has never been written. */
+export function readRevision(handle, sessionKey) {
+    const row = handle.db
+        .select({ revision: todoSession.revision })
+        .from(todoSession)
+        .where(eq(todoSession.sessionKey, sessionKey))
+        .get();
+    return row?.revision ?? 0;
+}
+/**
+ * Read-modify-write under one `IMMEDIATE` transaction.
+ *
+ * Every write goes through here so the read, the caller's transform, and the
+ * replacement cannot interleave with another process's write. Reading outside
+ * the transaction and writing inside it would allow a lost update: two
+ * processes could each read revision N, then both write revision N+1, and one
+ * change would silently disappear.
+ *
+ * The transform receives the current list and returns the next one; validation
+ * happens inside the transaction so an invalid result rolls the whole thing
+ * back without bumping the revision.
+ */
+export function mutateSessionTodos(handle, sessionKey, transform) {
+    return handle.db.transaction((tx) => {
+        const todos = selectTodos(tx, sessionKey);
+        const next = transform(todos);
+        const revision = writeSessionTodos(tx, sessionKey, next);
+        return { todos: next, revision };
+    }, { behavior: "immediate" });
+}
+/** Reads a session's list in `position` order, rebuilt into the nested shape. */
+export function selectTodos(executor, sessionKey) {
+    const rows = executor
+        .select()
+        .from(todoItem)
+        .where(eq(todoItem.sessionKey, sessionKey))
+        .orderBy(asc(todoItem.position))
+        .all();
+    const roots = new Map();
+    const order = [];
+    for (const row of rows) {
+        const base = {
+            id: Number(row.id),
+            content: row.content,
+            status: row.status,
+            ...(row.priority ? { priority: row.priority } : {}),
+            ...(row.note !== null && row.note !== undefined ? { note: row.note } : {}),
+        };
+        if (row.parentId === null) {
+            roots.set(row.id, base);
+            order.push(row.id);
+            continue;
+        }
+        const parent = roots.get(row.parentId);
+        if (!parent)
+            continue; // orphan; the foreign key prevents this
+        parent.children ??= [];
+        parent.children.push(base);
+    }
+    return order.map((id) => roots.get(id));
+}
+/**
+ * Writes the full list for a session inside a transaction, without opening one.
+ *
+ * Kept separate so `mutateSessionTodos` can compose it with a read in the same
+ * transaction.
+ */
+export function writeSessionTodos(tx, sessionKey, todos) {
+    const now = new Date().toISOString();
+    const existing = tx
+        .select({
+        revision: todoSession.revision,
+        createdAt: todoSession.createdAt,
+    })
+        .from(todoSession)
+        .where(eq(todoSession.sessionKey, sessionKey))
+        .get();
+    const revision = (existing?.revision ?? 0) + 1;
+    const createdAt = existing?.createdAt ?? now;
+    // A clear keeps the session row and still bumps the revision: the row holds
+    // `revision` and `hint_revision`, so dropping it would reset the change
+    // counter a reader polls and could re-emit an already-delivered hint. Only
+    // the items are removed, which the delete below does for every write.
+    if (existing) {
+        tx.update(todoSession)
+            .set({ revision, updatedAt: now })
+            .where(eq(todoSession.sessionKey, sessionKey))
+            .run();
+    }
+    else {
+        tx.insert(todoSession)
+            .values({ sessionKey, revision, createdAt, updatedAt: now })
+            .run();
+    }
+    // Replace rather than diff: callers always supply the full list, and
+    // delete-then-insert keeps `position` dense with no extra bookkeeping.
+    tx.delete(todoItem).where(eq(todoItem.sessionKey, sessionKey)).run();
+    let position = 0;
+    const rows = todos.flatMap((root) => {
+        const rootRow = {
+            sessionKey,
+            id: String(root.id),
+            parentId: null,
+            content: root.content,
+            status: root.status,
+            priority: root.priority ?? null,
+            note: root.note ?? null,
+            position: position++,
+        };
+        const childRows = (root.children ?? []).map((child) => ({
+            sessionKey,
+            id: String(child.id),
+            parentId: String(root.id),
+            content: child.content,
+            status: child.status,
+            priority: child.priority ?? null,
+            note: child.note ?? null,
+            position: position++,
+        }));
+        return [rootRow, ...childRows];
+    });
+    // Roots precede their children so the composite self-reference resolves
+    // within the same transaction.
+    if (rows.length > 0)
+        tx.insert(todoItem).values(rows).run();
+    return revision;
+}
+/**
+ * Imports one session folder. Returns what happened so the caller can report
+ * it; throws only on an unexpected filesystem error.
+ */
+function importSession(handle, sessionKey, sessionDir) {
+    const file = findLegacyTodoFile(sessionDir);
+    if (!file)
+        return "empty";
+    const todos = parseLegacyTodos(readFileSync(file, "utf8"));
+    // Refuse to merge into a session that already has rows: a second import
+    // would duplicate items, and silently merging is worse than skipping.
+    if (readRevision(handle, sessionKey) > 0)
+        return "skipped";
+    replaceSessionTodos(handle, sessionKey, todos);
+    // Only now is it safe to mark the source as consumed.
+    renameSync(file, file.replace(/\.json$/, MIGRATED_SUFFIX));
+    return "imported";
+}
+/**
+ * Scans every session folder under `baseDir` and imports the legacy JSON.
+ *
+ * Safe to run on every startup: sessions already present in SQLite are
+ * skipped, and consumed files no longer match the payload pattern.
+ */
+export function importLegacyJson(handle, baseDir) {
+    const result = { imported: [], skipped: [], failed: [] };
+    let entries;
+    try {
+        entries = readdirSync(baseDir);
+    }
+    catch {
+        return result;
+    }
+    for (const name of entries) {
+        const sessionDir = join(baseDir, name);
+        let file;
+        try {
+            file = findLegacyTodoFile(sessionDir);
+            if (!file)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // The hashed folder name is the session key; the legacy plaintext layout
+        // used the raw session id, which is also a valid key.
+        const sessionKey = name;
+        try {
+            const outcome = importSession(handle, sessionKey, sessionDir);
+            if (outcome === "imported")
+                result.imported.push(file);
+            else if (outcome === "skipped")
+                result.skipped.push(file);
+        }
+        catch (error) {
+            result.failed.push({
+                file,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return result;
+}