@dinoxx/dinox-cli 1.0.20 → 1.0.22

package/dist/commands/boxes/operations.js

@@ -0,0 +1,415 @@
+import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
+import { DinoxError } from '../../utils/errors.js';
+import { nowIsoUtc } from '../../utils/time.js';
+import { MAX_BOX_NAME_LENGTH, MAX_BOX_PATH_LENGTH, REQUIRED_NOTE_BOX_COLUMNS, assertMaxLength, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, parseStoredBoxIds, trimString, } from './model.js';
+import { activeBoxNodes, activeNodeByPath, assertCanWriteBox, assertRequiredColumns, assertWritableBoxNodes, descendantsOf, ensureNoPathConflict, getTableColumns, isActiveBoxNode, isDescendantBoxPath, loadAllBoxNodes, requireActivePath, toBoxListItem, } from './store.js';
+function buildSubtreeChanges(args) {
+    const newRootPath = canonicalizeBoxPath(args.newRootPath);
+    if (!newRootPath) {
+        throw new DinoxError('Target box path is required');
+    }
+    assertMaxLength('Box path', newRootPath, MAX_BOX_PATH_LENGTH);
+    const rootPrefix = `${args.root.path}/`;
+    return descendantsOf(args.nodes, args.root).map((node) => {
+        const suffix = node.id === args.root.id ? '' : node.path.slice(rootPrefix.length);
+        const toPath = suffix ? `${newRootPath}/${suffix}` : newRootPath;
+        return {
+            id: node.id,
+            fromPath: node.path,
+            toPath,
+        };
+    });
+}
+function parentPathOf(path) {
+    const segments = path.split('/');
+    if (segments.length <= 1) {
+        return null;
+    }
+    return segments.slice(0, -1).join('/');
+}
+function parentIdForTargetPath(args) {
+    const parentPath = parentPathOf(args.change.toPath);
+    if (!parentPath) {
+        return null;
+    }
+    const key = normalizeBoxLookupKey(parentPath);
+    const changedParent = args.changesByPath.get(key);
+    if (changedParent) {
+        return changedParent.id;
+    }
+    return args.activeNodesByPath.get(key)?.id ?? args.fallbackParentId;
+}
+async function applySubtreePathChanges(args) {
+    const changesByPath = new Map(args.changes.map((change) => [normalizeBoxLookupKey(change.toPath), change]));
+    const activeNodesByPath = activeNodeByPath(args.nodes);
+    for (const change of args.changes) {
+        const parentId = parentIdForTargetPath({
+            change,
+            changesByPath,
+            activeNodesByPath,
+            fallbackParentId: args.newRootParentId,
+        });
+        await args.db.execute(`
+      UPDATE c_zettel_box
+      SET name = ?, path = ?, parent_id = ?, updated_at = ?
+      WHERE id = ?
+      `, [getLeafName(change.toPath), change.toPath, parentId, args.timestamp, change.id]);
+    }
+}
+function parseRenameInput(input) {
+    const path = canonicalizeBoxPath(input.path);
+    const newName = canonicalizeBoxPath(input.newName);
+    const userId = trimString(input.userId);
+    if (!path) {
+        throw new DinoxError('Box path is required');
+    }
+    if (!newName || newName.includes('/')) {
+        throw new DinoxError('New box name must be a single path segment');
+    }
+    assertMaxLength('Box name', newName, MAX_BOX_NAME_LENGTH);
+    return { path, newName, userId };
+}
+function parseMoveInput(input) {
+    const path = canonicalizeBoxPath(input.path);
+    const to = canonicalizeBoxPath(input.to);
+    const userId = trimString(input.userId);
+    if (!path) {
+        throw new DinoxError('Box path is required');
+    }
+    if (!to) {
+        throw new DinoxError('Target parent path is required');
+    }
+    return { path, to, userId };
+}
+function parseMergeInput(input) {
+    const from = canonicalizeBoxPath(input.from);
+    const to = canonicalizeBoxPath(input.to);
+    const userId = trimString(input.userId);
+    if (!from) {
+        throw new DinoxError('Source box path is required');
+    }
+    if (!to) {
+        throw new DinoxError('Target box path is required');
+    }
+    return { from, to, userId };
+}
+export async function getBoxTree(db, input = {}) {
+    const nodes = activeBoxNodes(await loadAllBoxNodes(db, { userId: input.userId }));
+    const byId = new Map(nodes.map((node) => [node.id, { ...toBoxListItem(node), children: [] }]));
+    const roots = [];
+    for (const node of nodes) {
+        const treeNode = byId.get(node.id);
+        const parent = node.parentId ? byId.get(node.parentId) : null;
+        if (parent) {
+            parent.children.push(treeNode);
+        }
+        else {
+            roots.push(treeNode);
+        }
+    }
+    const sortTree = (items) => {
+        items.sort((left, right) => left.path.localeCompare(right.path));
+        for (const item of items) {
+            sortTree(item.children);
+        }
+    };
+    sortTree(roots);
+    return roots;
+}
+async function loadNoteBoxRows(db, userId) {
+    return db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      title,
+      zettel_boxes,
+      is_del,
+      TRIM(COALESCE(user_no, '')) AS user_no
+    FROM c_note
+    WHERE TRIM(COALESCE(id, '')) <> ''
+      AND (is_del IS NULL OR is_del = 0)
+      AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')
+    `, [userId]);
+}
+async function loadNoteBoxStats(db, userId) {
+    const normalizedUserId = trimString(userId);
+    const userFilter = normalizedUserId
+        ? `AND (TRIM(COALESCE(n.user_no, '')) = ? OR TRIM(COALESCE(n.user_no, '')) = '')`
+        : '';
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(CAST(box_item.value AS TEXT)) AS box_id,
+      COUNT(DISTINCT n.id) AS note_count,
+      MAX(COALESCE(n.updated_at, n.created_at)) AS latest_note_updated_at
+    FROM c_note n,
+      json_each(
+        CASE
+          WHEN json_valid(COALESCE(n.zettel_boxes, '')) THEN n.zettel_boxes
+          ELSE '[]'
+        END
+      ) box_item
+    WHERE (n.is_del IS NULL OR n.is_del = 0)
+      ${userFilter}
+      AND TRIM(CAST(box_item.value AS TEXT)) <> ''
+    GROUP BY TRIM(CAST(box_item.value AS TEXT))
+    `, normalizedUserId ? [normalizedUserId] : []);
+    const stats = new Map();
+    for (const row of rows) {
+        const id = trimString(row.box_id);
+        if (!id) {
+            continue;
+        }
+        stats.set(id, {
+            directNoteCount: Number(row.note_count ?? 0),
+            latestNoteUpdatedAt: row.latest_note_updated_at ?? null,
+        });
+    }
+    return stats;
+}
+export async function getBoxStats(db, input = {}) {
+    const nodes = activeBoxNodes(await loadAllBoxNodes(db, { userId: input.userId }));
+    const statsById = await loadNoteBoxStats(db, input.userId);
+    const descendantsById = new Map();
+    for (const node of nodes) {
+        descendantsById.set(node.id, descendantsOf(nodes, node));
+    }
+    const boxes = nodes.map((node) => {
+        const direct = statsById.get(node.id);
+        const descendantNodes = descendantsById.get(node.id) ?? [node];
+        let descendantNoteCount = 0;
+        let latestNoteUpdatedAt = direct?.latestNoteUpdatedAt ?? null;
+        for (const descendant of descendantNodes) {
+            const stats = statsById.get(descendant.id);
+            descendantNoteCount += stats?.directNoteCount ?? 0;
+            if (stats?.latestNoteUpdatedAt && (!latestNoteUpdatedAt || stats.latestNoteUpdatedAt > latestNoteUpdatedAt)) {
+                latestNoteUpdatedAt = stats.latestNoteUpdatedAt;
+            }
+        }
+        return {
+            ...toBoxListItem(node),
+            directNoteCount: direct?.directNoteCount ?? 0,
+            descendantNoteCount,
+            latestNoteUpdatedAt,
+            isEmpty: descendantNoteCount === 0,
+        };
+    });
+    boxes.sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        totalBoxes: boxes.length,
+        emptyBoxes: boxes.filter((box) => box.isEmpty).length,
+        boxes,
+    };
+}
+export async function inspectBoxCleanup(db, input = {}) {
+    const nodes = await loadAllBoxNodes(db, { userId: input.userId });
+    const stats = await getBoxStats(db, input);
+    const statsById = new Map(stats.boxes.map((box) => [box.id, box]));
+    const active = activeBoxNodes(nodes);
+    const activeIds = new Set(active.map((node) => node.id));
+    const issues = [];
+    for (const node of active) {
+        const boxStats = statsById.get(node.id);
+        if (boxStats?.isEmpty) {
+            issues.push({
+                type: 'empty_box',
+                id: node.id,
+                path: node.path,
+                name: node.name,
+                parentId: node.parentId,
+                detail: 'Box has no notes in itself or descendants.',
+            });
+        }
+        if (node.parentId && !activeIds.has(node.parentId)) {
+            issues.push({
+                type: 'orphan_parent',
+                id: node.id,
+                path: node.path,
+                name: node.name,
+                parentId: node.parentId,
+                detail: `Parent box is missing or deleted: ${node.parentId}`,
+            });
+        }
+    }
+    const byPath = new Map();
+    for (const node of active) {
+        const key = normalizeBoxLookupKey(node.path);
+        byPath.set(key, [...(byPath.get(key) ?? []), node]);
+    }
+    for (const duplicates of byPath.values()) {
+        if (duplicates.length <= 1) {
+            continue;
+        }
+        for (const node of duplicates) {
+            issues.push({
+                type: 'duplicate_path',
+                id: node.id,
+                path: node.path,
+                name: node.name,
+                parentId: node.parentId,
+                duplicateIds: duplicates.map((item) => item.id),
+                detail: `Active duplicate path appears ${duplicates.length} times.`,
+            });
+        }
+    }
+    const activeChildrenByDeletedParent = new Map();
+    for (const child of active) {
+        if (!child.parentId) {
+            continue;
+        }
+        const parent = nodes.find((node) => node.id === child.parentId);
+        if (parent && !isActiveBoxNode(parent)) {
+            activeChildrenByDeletedParent.set(parent.id, [...(activeChildrenByDeletedParent.get(parent.id) ?? []), child]);
+        }
+    }
+    for (const [parentId, children] of activeChildrenByDeletedParent.entries()) {
+        const parent = nodes.find((node) => node.id === parentId);
+        issues.push({
+            type: 'deleted_with_active_children',
+            id: parent.id,
+            path: parent.path,
+            name: parent.name,
+            parentId: parent.parentId,
+            childIds: children.map((child) => child.id),
+            detail: 'Deleted box still has active children.',
+        });
+    }
+    issues.sort((left, right) => `${left.type}:${left.path}:${left.id}`.localeCompare(`${right.type}:${right.path}:${right.id}`));
+    return {
+        issues,
+        emptyBoxes: issues.filter((issue) => issue.type === 'empty_box').length,
+        duplicatePaths: issues.filter((issue) => issue.type === 'duplicate_path').length,
+        orphanParents: issues.filter((issue) => issue.type === 'orphan_parent').length,
+        deletedWithActiveChildren: issues.filter((issue) => issue.type === 'deleted_with_active_children').length,
+    };
+}
+export async function renameBox(db, input, options = {}) {
+    const parsed = parseRenameInput(input);
+    const columns = await getTableColumns(db, 'c_zettel_box');
+    assertCanWriteBox(columns, parsed.userId, 'update');
+    const nodes = await loadAllBoxNodes(db, { userId: parsed.userId });
+    const root = requireActivePath(nodes, parsed.path, 'Box path');
+    const parentPath = root.path.includes('/') ? root.path.split('/').slice(0, -1).join('/') : '';
+    const toPath = parentPath ? `${parentPath}/${parsed.newName}` : parsed.newName;
+    const changes = buildSubtreeChanges({ nodes, root, newRootPath: toPath });
+    ensureNoPathConflict(nodes, changes);
+    assertWritableBoxNodes(nodes, new Set(changes.map((change) => change.id)), parsed.userId);
+    if (!options.dryRun) {
+        await withPowerSyncWriteTransaction(db, async (tx) => {
+            await applySubtreePathChanges({
+                db: tx,
+                nodes,
+                changes,
+                newRootParentId: root.parentId,
+                timestamp: nowIsoUtc(),
+            });
+        });
+    }
+    return {
+        id: root.id,
+        fromPath: root.path,
+        toPath,
+        updatedBoxes: changes,
+    };
+}
+export async function moveBox(db, input, options = {}) {
+    const parsed = parseMoveInput(input);
+    const columns = await getTableColumns(db, 'c_zettel_box');
+    assertCanWriteBox(columns, parsed.userId, 'update');
+    const nodes = await loadAllBoxNodes(db, { userId: parsed.userId });
+    const root = requireActivePath(nodes, parsed.path, 'Box path');
+    const targetParent = requireActivePath(nodes, parsed.to, 'Target parent path');
+    if (root.id === targetParent.id || isDescendantBoxPath(targetParent.path, root.path)) {
+        throw new DinoxError('Cannot move a zettel box under itself or one of its descendants');
+    }
+    const toPath = `${targetParent.path}/${root.name}`;
+    const changes = buildSubtreeChanges({ nodes, root, newRootPath: toPath });
+    ensureNoPathConflict(nodes, changes);
+    assertWritableBoxNodes(nodes, new Set(changes.map((change) => change.id)), parsed.userId);
+    if (!options.dryRun) {
+        await withPowerSyncWriteTransaction(db, async (tx) => {
+            await applySubtreePathChanges({
+                db: tx,
+                nodes,
+                changes,
+                newRootParentId: targetParent.id,
+                timestamp: nowIsoUtc(),
+            });
+        });
+    }
+    return {
+        id: root.id,
+        fromPath: root.path,
+        toPath,
+        updatedBoxes: changes,
+    };
+}
+function remapNoteBoxIds(current, sourceIds, targetId) {
+    const next = [];
+    const seen = new Set();
+    for (const id of current) {
+        const mapped = sourceIds.has(id) ? targetId : id;
+        if (!mapped || seen.has(mapped)) {
+            continue;
+        }
+        seen.add(mapped);
+        next.push(mapped);
+    }
+    return next;
+}
+function sameIds(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+export async function mergeBox(db, input, options = {}) {
+    const parsed = parseMergeInput(input);
+    const boxColumns = await getTableColumns(db, 'c_zettel_box');
+    const noteColumns = await getTableColumns(db, 'c_note');
+    assertCanWriteBox(boxColumns, parsed.userId, 'update');
+    assertRequiredColumns('c_note', noteColumns, REQUIRED_NOTE_BOX_COLUMNS);
+    const nodes = await loadAllBoxNodes(db, { userId: parsed.userId });
+    const source = requireActivePath(nodes, parsed.from, 'Source box path');
+    const target = requireActivePath(nodes, parsed.to, 'Target box path');
+    if (source.id === target.id || isDescendantBoxPath(target.path, source.path)) {
+        throw new DinoxError('Cannot merge a zettel box into itself or one of its descendants');
+    }
+    const sourceNodes = descendantsOf(nodes, source);
+    const sourceIds = new Set(sourceNodes.map((node) => node.id));
+    assertWritableBoxNodes(nodes, new Set([...sourceIds, target.id]), parsed.userId);
+    const noteRows = await loadNoteBoxRows(db, parsed.userId);
+    const updatedNotes = noteRows
+        .map((row) => {
+        const before = parseStoredBoxIds(row.zettel_boxes);
+        const after = remapNoteBoxIds(before, sourceIds, target.id);
+        return { id: trimString(row.id), before, after };
+    })
+        .filter((row) => row.id && !sameIds(row.before, row.after));
+    const softDeletedBoxIds = sourceNodes.map((node) => node.id);
+    if (!options.dryRun) {
+        await withPowerSyncWriteTransaction(db, async (tx) => {
+            const timestamp = nowIsoUtc();
+            for (const note of updatedNotes) {
+                await tx.execute(`
+          UPDATE c_note
+          SET zettel_boxes = ?, updated_at = ?, version = COALESCE(version, 0) + 1
+          WHERE id = ?
+          `, [JSON.stringify(note.after), timestamp, note.id]);
+            }
+            for (const boxId of softDeletedBoxIds) {
+                await tx.execute(`
+          UPDATE c_zettel_box
+          SET is_del = 1, updated_at = ?
+          WHERE id = ?
+          `, [timestamp, boxId]);
+            }
+        });
+    }
+    return {
+        fromId: source.id,
+        toId: target.id,
+        fromPath: source.path,
+        toPath: target.path,
+        softDeletedBoxIds,
+        updatedNotes,
+    };
+}

package/dist/commands/boxes/repo.d.ts

@@ -1,29 +1,36 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
-export type BoxListItem = {
-    id: string;
-    name: string;
-    description: string;
-};
+import type { BoxListItem } from './model.js';
+export { canonicalizeBoxPath } from './model.js';
 export type AddBoxInput = {
     name: string;
     userId: string;
     description?: string;
     color?: string;
 };
+export type ListBoxesInput = {
+    userId?: string;
+};
 export type AddBoxResult = {
     id: string;
     name: string;
+    path: string;
+    parentId: string | null;
     description: string;
     color: string;
     restored: boolean;
+    createdNodes: number;
+    restoredNodes: number;
 };
 export type InspectAddBoxResult = {
     name: string;
+    path: string;
     description: string;
     color: string;
     restored: boolean;
+    createdPaths: string[];
+    restoredPaths: string[];
     existingId?: string;
 };
-export declare function listBoxes(db: AbstractPowerSyncDatabase): Promise<BoxListItem[]>;
+export declare function listBoxes(db: AbstractPowerSyncDatabase, input?: ListBoxesInput): Promise<BoxListItem[]>;
 export declare function addBox(db: AbstractPowerSyncDatabase, input: AddBoxInput): Promise<AddBoxResult>;
 export declare function inspectAddBox(db: AbstractPowerSyncDatabase, input: AddBoxInput): Promise<InspectAddBoxResult>;