@dinoxx/dinox-cli 1.0.20 → 1.0.21

package/dist/commands/boxes/repo.js

@@ -1,20 +1,40 @@
 import { generateId } from '../../utils/id.js';
 import { DinoxError } from '../../utils/errors.js';
-function normalizeName(value) {
-    return value.trim();
+import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
+import { MAX_BOX_COLOR_LENGTH, MAX_BOX_DESCRIPTION_LENGTH, MAX_BOX_NAME_LENGTH, MAX_BOX_PATH_LENGTH, assertMaxLength, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, toNullableId, trimString, } from './model.js';
+import { assertCanWriteBox, getTableColumns } from './store.js';
+export { canonicalizeBoxPath } from './model.js';
+function normalizeLookupKey(value) {
+    return normalizeBoxLookupKey(value);
 }
-function normalizeLookup(value) {
-    return normalizeName(value).toLowerCase();
-}
-async function getBoxColumns(db) {
-    const rows = await db.getAll('PRAGMA table_info(c_zettel_box)', []);
-    return new Set(rows.map((row) => row.name).filter(Boolean));
+function parseAddBoxInput(input) {
+    const userId = input.userId.trim();
+    const path = canonicalizeBoxPath(input.name);
+    if (!path) {
+        throw new DinoxError('Box path is required');
+    }
+    const name = getLeafName(path);
+    const description = trimString(input.description);
+    const color = trimString(input.color);
+    assertMaxLength('Box name', name, MAX_BOX_NAME_LENGTH);
+    assertMaxLength('Box path', path, MAX_BOX_PATH_LENGTH);
+    assertMaxLength('Box description', description, MAX_BOX_DESCRIPTION_LENGTH);
+    assertMaxLength('Box color', color, MAX_BOX_COLOR_LENGTH);
+    return {
+        userId,
+        path,
+        name,
+        description,
+        color,
+    };
 }
-async function listBoxRowsForWrite(db) {
-    return db.getAll(`
+async function loadBoxNodesByPath(db) {
+    const rows = await db.getAll(`
     SELECT
       TRIM(COALESCE(id, '')) AS id,
       TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(path, name, '')) AS path,
+      TRIM(COALESCE(parent_id, '')) AS parent_id,
       TRIM(COALESCE(description, '')) AS description,
       TRIM(COALESCE(color, '')) AS color,
       is_del,
@@ -27,169 +47,272 @@ async function listBoxRowsForWrite(db) {
       created_at DESC,
       id DESC
     `, []);
+    const nodesByPath = new Map();
+    for (const row of rows) {
+        const id = trimString(row.id);
+        if (!id) {
+            continue;
+        }
+        const path = canonicalizeBoxPath(row.path ?? row.name ?? '');
+        if (!path) {
+            continue;
+        }
+        const key = normalizeLookupKey(path);
+        if (nodesByPath.has(key)) {
+            continue;
+        }
+        nodesByPath.set(key, {
+            id,
+            name: trimString(row.name) || getLeafName(path),
+            path,
+            parentId: toNullableId(row.parent_id),
+            description: trimString(row.description),
+            color: trimString(row.color),
+            isDel: typeof row.is_del === 'number' ? row.is_del : null,
+            userNo: trimString(row.user_no),
+        });
+    }
+    return nodesByPath;
 }
-export async function listBoxes(db) {
+export async function listBoxes(db, input = {}) {
+    const userId = trimString(input.userId);
+    const userFilter = userId
+        ? `AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')`
+        : '';
     const rows = await db.getAll(`
     SELECT DISTINCT
       TRIM(COALESCE(id, '')) AS id,
       TRIM(COALESCE(name, '')) AS name,
-      TRIM(COALESCE(description, '')) AS description
+      TRIM(COALESCE(path, name, '')) AS path,
+      TRIM(COALESCE(parent_id, '')) AS parent_id,
+      TRIM(COALESCE(description, '')) AS description,
+      TRIM(COALESCE(color, '')) AS color
     FROM c_zettel_box
     WHERE (is_del IS NULL OR is_del = 0)
       AND TRIM(COALESCE(id, '')) <> ''
-    ORDER BY name COLLATE NOCASE ASC, id ASC
-    `, []);
+      ${userFilter}
+    ORDER BY path COLLATE NOCASE ASC, id ASC
+    `, userId ? [userId] : []);
     return rows
-        .map((row) => ({
-        id: row.id?.trim() ?? '',
-        name: row.name?.trim() ?? '',
-        description: row.description?.trim() ?? '',
-    }))
-        .filter((row) => row.id.length > 0);
+        .map((row) => {
+        const path = canonicalizeBoxPath(row.path ?? row.name ?? '');
+        return {
+            id: trimString(row.id),
+            name: trimString(row.name) || (path ? getLeafName(path) : ''),
+            path,
+            parentId: toNullableId(row.parent_id),
+            description: trimString(row.description),
+            color: trimString(row.color),
+        };
+    })
+        .filter((row) => row.id.length > 0 && row.path.length > 0);
 }
-export async function addBox(db, input) {
-    const userId = input.userId.trim();
-    const name = normalizeName(input.name);
-    if (!name) {
-        throw new DinoxError('Box name is required');
+function buildBoxExistsError(path, ids) {
+    return new DinoxError(`Zettel box already exists: ${path}`, {
+        details: {
+            type: 'box_exists',
+            name: getLeafName(path),
+            path,
+            ids,
+            question: 'This box already exists. Do you want to keep using the existing box?',
+        },
+    });
+}
+function setExistingValue(assignments, params, node, field, column, value) {
+    if (node[field] === value) {
+        return;
     }
-    const description = normalizeName(input.description ?? '');
-    const color = normalizeName(input.color ?? '');
-    const lookup = normalizeLookup(name);
-    const columnNames = await getBoxColumns(db);
-    const requiredColumns = ['id', 'name', 'user_no'];
-    const missingRequired = requiredColumns.filter((column) => !columnNames.has(column));
-    if (missingRequired.length > 0) {
-        throw new DinoxError(`c_zettel_box table is missing required columns: ${missingRequired.join(', ')}`);
+    assignments.push(`${column} = ?`);
+    params.push(value);
+    node[field] = value;
+}
+async function restoreOrUpdateExistingBox(args) {
+    const { db, node, name, path, parentId, description, color, userId, timestamp, isLeaf } = args;
+    const assignments = [];
+    const params = [];
+    const wasDeleted = node.isDel === 1;
+    if (wasDeleted) {
+        assignments.push('is_del = ?');
+        params.push(0);
+        node.isDel = 0;
     }
-    if (!userId) {
-        throw new DinoxError('c_zettel_box insert requires user_no. Missing persisted userId. Run `dino auth login` first.');
+    setExistingValue(assignments, params, node, 'name', 'name', name);
+    setExistingValue(assignments, params, node, 'path', 'path', path);
+    setExistingValue(assignments, params, node, 'parentId', 'parent_id', parentId);
+    if (!node.userNo) {
+        setExistingValue(assignments, params, node, 'userNo', 'user_no', userId);
     }
-    const rows = await listBoxRowsForWrite(db);
-    const sameNameRows = rows.filter((row) => normalizeLookup(row.name ?? '') === lookup);
-    const activeRows = sameNameRows.filter((row) => row.is_del !== 1);
-    if (activeRows.length > 0) {
-        const ids = activeRows.map((row) => row.id?.trim() ?? '').filter(Boolean);
-        throw new DinoxError(`Zettel box already exists: ${name}`, {
-            details: {
-                type: 'box_exists',
-                name,
-                ids,
-                question: 'This box already exists. Do you want to keep using the existing box?',
-            },
-        });
+    if (isLeaf && description) {
+        setExistingValue(assignments, params, node, 'description', 'description', description);
+    }
+    if (isLeaf && color) {
+        setExistingValue(assignments, params, node, 'color', 'color', color);
+    }
+    if (assignments.length === 0) {
+        return false;
+    }
+    assignments.unshift('updated_at = ?');
+    params.unshift(timestamp);
+    params.push(node.id);
+    await db.execute(`
+    UPDATE c_zettel_box
+    SET ${assignments.join(', ')}
+    WHERE id = ?
+    `, params);
+    return wasDeleted;
+}
+async function insertBoxNode(args) {
+    const { db, id, name, path, parentId, description, color, userId, timestamp } = args;
+    await db.execute(`
+    INSERT INTO c_zettel_box (
+      id,
+      name,
+      path,
+      parent_id,
+      description,
+      color,
+      priority,
+      is_show,
+      cover_url,
+      created_at,
+      updated_at,
+      extra_data,
+      user_no,
+      is_del
+    ) VALUES (?, ?, ?, ?, ?, ?, 0, 1, '', ?, ?, '{}', ?, 0)
+    `, [id, name, path, parentId, description, color, timestamp, timestamp, userId]);
+}
+export async function addBox(db, input) {
+    const parsed = parseAddBoxInput(input);
+    const columnNames = await getTableColumns(db, 'c_zettel_box');
+    assertCanWriteBox(columnNames, parsed.userId, 'insert');
+    const nodesByPath = await loadBoxNodesByPath(db);
+    const existingLeaf = nodesByPath.get(normalizeLookupKey(parsed.path));
+    if (existingLeaf && existingLeaf.isDel !== 1) {
+        throw buildBoxExistsError(parsed.path, [existingLeaf.id]);
     }
     const timestamp = new Date().toISOString();
-    const deletedRow = sameNameRows.find((row) => (row.id?.trim() ?? '').length > 0);
-    if (deletedRow?.id) {
-        const setParts = [];
-        const params = [];
-        const setValue = (column, value) => {
-            if (!columnNames.has(column)) {
-                return;
+    const segments = parsed.path.split('/');
+    let parentId = null;
+    let leafId = '';
+    let leafParentId = null;
+    let leafDescription = '';
+    let leafColor = '';
+    let createdNodes = 0;
+    let restoredNodes = 0;
+    let restoredLeaf = false;
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        for (let index = 0; index < segments.length; index += 1) {
+            const path = segments.slice(0, index + 1).join('/');
+            const key = normalizeLookupKey(path);
+            const name = segments[index];
+            const isLeaf = index === segments.length - 1;
+            const existing = nodesByPath.get(key);
+            if (existing) {
+                const restored = await restoreOrUpdateExistingBox({
+                    db: tx,
+                    node: existing,
+                    name,
+                    path,
+                    parentId,
+                    description: parsed.description,
+                    color: parsed.color,
+                    userId: parsed.userId,
+                    timestamp,
+                    isLeaf,
+                });
+                if (restored) {
+                    restoredNodes += 1;
+                    restoredLeaf = isLeaf;
+                }
+                parentId = existing.id;
+                if (isLeaf) {
+                    leafId = existing.id;
+                    leafParentId = existing.parentId;
+                    leafDescription = existing.description;
+                    leafColor = existing.color;
+                }
+                continue;
+            }
+            const id = generateId();
+            await insertBoxNode({
+                db: tx,
+                id,
+                name,
+                path,
+                parentId,
+                description: isLeaf && parsed.description ? parsed.description : null,
+                color: isLeaf && parsed.color ? parsed.color : null,
+                userId: parsed.userId,
+                timestamp,
+            });
+            const node = {
+                id,
+                name,
+                path,
+                parentId,
+                description: isLeaf ? parsed.description : '',
+                color: isLeaf ? parsed.color : '',
+                isDel: 0,
+                userNo: parsed.userId,
+            };
+            nodesByPath.set(key, node);
+            createdNodes += 1;
+            parentId = id;
+            if (isLeaf) {
+                leafId = id;
+                leafParentId = node.parentId;
+                leafDescription = node.description;
+                leafColor = node.color;
             }
-            setParts.push(`${column} = ?`);
-            params.push(value);
-        };
-        setValue('name', name);
-        setValue('is_del', 0);
-        setValue('updated_at', timestamp);
-        if (description) {
-            setValue('description', description);
-        }
-        if (color) {
-            setValue('color', color);
-        }
-        setValue('user_no', userId);
-        if (setParts.length > 0) {
-            params.push(deletedRow.id);
-            await db.execute(`
-        UPDATE c_zettel_box
-        SET ${setParts.join(', ')}
-        WHERE id = ?
-        `, params);
         }
-        return {
-            id: deletedRow.id,
-            name,
-            description: description || (deletedRow.description?.trim() ?? ''),
-            color: color || (deletedRow.color?.trim() ?? ''),
-            restored: true,
-        };
+    });
+    if (!leafId) {
+        throw new DinoxError(`Failed to create zettel box: ${parsed.path}`);
     }
-    const id = generateId();
-    const insertEntries = [];
-    const pushInsert = (column, value) => {
-        if (!columnNames.has(column)) {
-            return;
-        }
-        insertEntries.push([column, value]);
-    };
-    pushInsert('id', id);
-    pushInsert('name', name);
-    pushInsert('description', description || null);
-    pushInsert('color', color || null);
-    pushInsert('priority', 0);
-    pushInsert('is_show', 1);
-    pushInsert('cover_url', '');
-    pushInsert('created_at', timestamp);
-    pushInsert('updated_at', timestamp);
-    pushInsert('extra_data', '{}');
-    pushInsert('user_no', userId);
-    pushInsert('is_del', 0);
-    const insertColumns = insertEntries.map(([column]) => column);
-    const placeholders = insertColumns.map(() => '?').join(', ');
-    const insertParams = insertEntries.map(([, value]) => value);
-    await db.execute(`
-    INSERT INTO c_zettel_box (${insertColumns.join(', ')})
-    VALUES (${placeholders})
-    `, insertParams);
     return {
-        id,
-        name,
-        description,
-        color,
-        restored: false,
+        id: leafId,
+        name: parsed.name,
+        path: parsed.path,
+        parentId: leafParentId,
+        description: leafDescription,
+        color: leafColor,
+        restored: restoredLeaf,
+        createdNodes,
+        restoredNodes,
     };
 }
 export async function inspectAddBox(db, input) {
-    const userId = input.userId.trim();
-    const name = normalizeName(input.name);
-    if (!name) {
-        throw new DinoxError('Box name is required');
-    }
-    const description = normalizeName(input.description ?? '');
-    const color = normalizeName(input.color ?? '');
-    const lookup = normalizeLookup(name);
-    const columnNames = await getBoxColumns(db);
-    const requiredColumns = ['id', 'name', 'user_no'];
-    const missingRequired = requiredColumns.filter((column) => !columnNames.has(column));
-    if (missingRequired.length > 0) {
-        throw new DinoxError(`c_zettel_box table is missing required columns: ${missingRequired.join(', ')}`);
-    }
-    if (!userId) {
-        throw new DinoxError('c_zettel_box insert requires user_no. Missing persisted userId. Run `dino auth login` first.');
+    const parsed = parseAddBoxInput(input);
+    const columnNames = await getTableColumns(db, 'c_zettel_box');
+    assertCanWriteBox(columnNames, parsed.userId, 'insert');
+    const nodesByPath = await loadBoxNodesByPath(db);
+    const existingLeaf = nodesByPath.get(normalizeLookupKey(parsed.path));
+    if (existingLeaf && existingLeaf.isDel !== 1) {
+        throw buildBoxExistsError(parsed.path, [existingLeaf.id]);
     }
-    const rows = await listBoxRowsForWrite(db);
-    const sameNameRows = rows.filter((row) => normalizeLookup(row.name ?? '') === lookup);
-    const activeRows = sameNameRows.filter((row) => row.is_del !== 1);
-    if (activeRows.length > 0) {
-        const ids = activeRows.map((row) => row.id?.trim() ?? '').filter(Boolean);
-        throw new DinoxError(`Zettel box already exists: ${name}`, {
-            details: {
-                type: 'box_exists',
-                name,
-                ids,
-                question: 'This box already exists. Do you want to keep using the existing box?',
-            },
-        });
+    const segments = parsed.path.split('/');
+    const createdPaths = [];
+    const restoredPaths = [];
+    for (let index = 0; index < segments.length; index += 1) {
+        const path = segments.slice(0, index + 1).join('/');
+        const existing = nodesByPath.get(normalizeLookupKey(path));
+        if (!existing) {
+            createdPaths.push(path);
+            continue;
+        }
+        if (existing.isDel === 1) {
+            restoredPaths.push(path);
+        }
     }
-    const deletedRow = sameNameRows.find((row) => (row.id?.trim() ?? '').length > 0);
     return {
-        name,
-        description,
-        color,
-        restored: Boolean(deletedRow?.id),
-        ...(deletedRow?.id ? { existingId: deletedRow.id } : {}),
+        name: parsed.name,
+        path: parsed.path,
+        description: parsed.description,
+        color: parsed.color,
+        restored: existingLeaf?.isDel === 1,
+        createdPaths,
+        restoredPaths,
+        ...(existingLeaf?.id ? { existingId: existingLeaf.id } : {}),
     };
 }

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

@@ -0,0 +1,22 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { BoxListItem, MutableBoxNode } from './model.js';
+type BoxTableName = 'c_zettel_box' | 'c_note';
+export declare function getTableColumns(db: AbstractPowerSyncDatabase, table: BoxTableName): Promise<Set<string>>;
+export declare function assertRequiredColumns(table: string, columnNames: Set<string>, required: string[]): void;
+export declare function assertCanWriteBox(columnNames: Set<string>, userId: string, action: 'insert' | 'update'): void;
+export declare function loadAllBoxNodes(db: AbstractPowerSyncDatabase, options?: {
+    userId?: string;
+}): Promise<MutableBoxNode[]>;
+export declare function isActiveBoxNode(node: MutableBoxNode): boolean;
+export declare function toBoxListItem(node: MutableBoxNode): BoxListItem;
+export declare function activeBoxNodes(nodes: MutableBoxNode[]): MutableBoxNode[];
+export declare function activeNodeByPath(nodes: MutableBoxNode[]): Map<string, MutableBoxNode>;
+export declare function requireActivePath(nodes: MutableBoxNode[], rawPath: string, label: string): MutableBoxNode;
+export declare function isDescendantBoxPath(candidatePath: string, rootPath: string): boolean;
+export declare function descendantsOf(nodes: MutableBoxNode[], root: MutableBoxNode, includeRoot?: boolean): MutableBoxNode[];
+export declare function ensureNoPathConflict(nodes: MutableBoxNode[], changes: Array<{
+    id: string;
+    toPath: string;
+}>): void;
+export declare function assertWritableBoxNodes(nodes: MutableBoxNode[], ids: Set<string>, userId: string): void;
+export {};

package/dist/commands/boxes/store.js

@@ -0,0 +1,143 @@
+import { DinoxError } from '../../utils/errors.js';
+import { REQUIRED_ZETTEL_BOX_COLUMNS, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, toNullableId, trimString, } from './model.js';
+export async function getTableColumns(db, table) {
+    const sql = table === 'c_zettel_box' ? 'PRAGMA table_info(c_zettel_box)' : 'PRAGMA table_info(c_note)';
+    const rows = await db.getAll(sql, []);
+    return new Set(rows.map((row) => trimString(row.name)).filter(Boolean));
+}
+export function assertRequiredColumns(table, columnNames, required) {
+    const missing = required.filter((column) => !columnNames.has(column));
+    if (missing.length > 0) {
+        throw new DinoxError(`${table} table is missing required columns: ${missing.join(', ')}`);
+    }
+}
+export function assertCanWriteBox(columnNames, userId, action) {
+    assertRequiredColumns('c_zettel_box', columnNames, REQUIRED_ZETTEL_BOX_COLUMNS);
+    if (!userId.trim()) {
+        throw new DinoxError(`c_zettel_box ${action} requires user_no. Missing resolved userId. Run \`dino auth login\` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.`);
+    }
+}
+export async function loadAllBoxNodes(db, options = {}) {
+    const userId = trimString(options.userId);
+    const userFilter = userId
+        ? `AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')`
+        : '';
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(path, name, '')) AS path,
+      TRIM(COALESCE(parent_id, '')) AS parent_id,
+      TRIM(COALESCE(description, '')) AS description,
+      TRIM(COALESCE(color, '')) AS color,
+      is_del,
+      TRIM(COALESCE(user_no, '')) AS user_no
+    FROM c_zettel_box
+    WHERE TRIM(COALESCE(id, '')) <> ''
+      ${userFilter}
+    ORDER BY path COLLATE NOCASE ASC, id ASC
+    `, userId ? [userId] : []);
+    return rows
+        .map((row) => {
+        const path = canonicalizeBoxPath(row.path ?? row.name ?? '');
+        return {
+            id: trimString(row.id),
+            name: trimString(row.name) || (path ? getLeafName(path) : ''),
+            path,
+            parentId: toNullableId(row.parent_id),
+            description: trimString(row.description),
+            color: trimString(row.color),
+            isDel: typeof row.is_del === 'number' ? row.is_del : null,
+            userNo: trimString(row.user_no),
+        };
+    })
+        .filter((row) => row.id && row.path);
+}
+export function isActiveBoxNode(node) {
+    return node.isDel === null || node.isDel === 0;
+}
+export function toBoxListItem(node) {
+    return {
+        id: node.id,
+        name: node.name,
+        path: node.path,
+        parentId: node.parentId,
+        description: node.description,
+        color: node.color,
+    };
+}
+export function activeBoxNodes(nodes) {
+    return nodes.filter(isActiveBoxNode);
+}
+export function activeNodeByPath(nodes) {
+    const map = new Map();
+    for (const node of activeBoxNodes(nodes)) {
+        const key = normalizeBoxLookupKey(node.path);
+        if (!map.has(key)) {
+            map.set(key, node);
+        }
+    }
+    return map;
+}
+export function requireActivePath(nodes, rawPath, label) {
+    const path = canonicalizeBoxPath(rawPath);
+    if (!path) {
+        throw new DinoxError(`${label} is required`);
+    }
+    const node = activeNodeByPath(nodes).get(normalizeBoxLookupKey(path));
+    if (!node) {
+        throw new DinoxError(`Unknown zettel box path: ${path}`);
+    }
+    return node;
+}
+export function isDescendantBoxPath(candidatePath, rootPath) {
+    const candidateKey = normalizeBoxLookupKey(candidatePath);
+    const rootKey = normalizeBoxLookupKey(rootPath);
+    return candidateKey.startsWith(`${rootKey}/`);
+}
+export function descendantsOf(nodes, root, includeRoot = true) {
+    return activeBoxNodes(nodes)
+        .filter((node) => {
+        if (includeRoot && node.id === root.id) {
+            return true;
+        }
+        return isDescendantBoxPath(node.path, root.path);
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+export function ensureNoPathConflict(nodes, changes) {
+    const changedIds = new Set(changes.map((change) => change.id));
+    const activePaths = new Map();
+    for (const node of activeBoxNodes(nodes)) {
+        if (changedIds.has(node.id)) {
+            continue;
+        }
+        activePaths.set(normalizeBoxLookupKey(node.path), node);
+    }
+    const seenNext = new Set();
+    for (const change of changes) {
+        const key = normalizeBoxLookupKey(change.toPath);
+        const existing = activePaths.get(key);
+        if (existing) {
+            throw new DinoxError(`Target zettel box path already exists: ${change.toPath}`, {
+                details: {
+                    type: 'box_path_conflict',
+                    path: change.toPath,
+                    existingId: existing.id,
+                },
+            });
+        }
+        if (seenNext.has(key)) {
+            throw new DinoxError(`Duplicate target zettel box path in operation: ${change.toPath}`);
+        }
+        seenNext.add(key);
+    }
+}
+export function assertWritableBoxNodes(nodes, ids, userId) {
+    const foreign = nodes
+        .filter((node) => ids.has(node.id))
+        .filter((node) => node.userNo && node.userNo !== userId);
+    if (foreign.length > 0) {
+        throw new DinoxError(`Zettel boxes belong to a different user: ${foreign.map((node) => node.path).join(', ')}`);
+    }
+}