@dinoxx/dinox-cli 2.0.0 → 2.1.1

package/dist/commands/notes/repo/shared.js

@@ -0,0 +1,102 @@
+// Row and result types plus stored-value normalizers shared by the note repository modules.
+import { canonicalizeBoxPath } from '../../boxes/repo.js';
+export const MAX_SEARCH_SUMMARY_CHARS = 200;
+export function normalizeStoredFlag(value) {
+    if (typeof value === 'number') {
+        return value === 1;
+    }
+    if (typeof value === 'string') {
+        return value.trim() === '1';
+    }
+    return false;
+}
+export function normalizeStoredStarred(value) {
+    return normalizeStoredFlag(value);
+}
+export function parseStoredTags(raw) {
+    if (!raw) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        const result = [];
+        const seen = new Set();
+        for (const value of parsed) {
+            const normalized = String(value).trim();
+            const key = normalizeLookupKey(normalized);
+            if (!key || seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            result.push(normalized);
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+export function parseZettelBoxIds(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return Array.from(new Set(parsed
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry.length > 0)));
+    }
+    catch {
+        return [];
+    }
+}
+export async function loadZettelBoxNameMap(db, ids) {
+    const map = new Map();
+    if (ids.length === 0) {
+        return map;
+    }
+    const chunkSize = 500;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+        const batch = ids.slice(i, i + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT id, name, path
+      FROM c_zettel_box
+      WHERE (is_del IS NULL OR is_del = 0)
+        AND id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (!id) {
+                continue;
+            }
+            const path = canonicalizeBoxPath(row.path ?? row.name ?? '');
+            map.set(id, path || row.name?.trim() || '');
+        }
+    }
+    return map;
+}
+export function resolveSummary(summary, contentText) {
+    const summaryValue = summary?.trim() ?? '';
+    if (summaryValue.length > 0) {
+        return truncateSearchSummary(summaryValue);
+    }
+    return truncateSearchSummary(contentText?.trim() ?? '');
+}
+export function truncateSearchSummary(value) {
+    const chars = Array.from(value);
+    if (chars.length <= MAX_SEARCH_SUMMARY_CHARS) {
+        return value;
+    }
+    return chars.slice(0, MAX_SEARCH_SUMMARY_CHARS).join('');
+}
+export function normalizeLookupKey(value) {
+    return value.trim().toLowerCase();
+}

package/dist/commands/notes/repo/write.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type UpdateNoteResult } from './shared.js';
+export declare function createNote(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    title: string;
+    noteType: 'note' | 'crawl';
+    contentMd: string;
+    contentText: string;
+    contentJson: unknown;
+    tags: string[];
+    zettelBoxIds: string[];
+    userId: string;
+    imageDetail?: unknown[];
+}): Promise<{
+    id: string;
+}>;
+export declare function updateNote(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    tags?: string[];
+    zettelBoxIds?: string[];
+    starred?: boolean;
+}): Promise<UpdateNoteResult>;
+export declare function assertNotesUpdatable(db: AbstractPowerSyncDatabase, noteIds: string[]): Promise<void>;
+export declare function softDeleteNote(db: AbstractPowerSyncDatabase, id: string): Promise<void>;

package/dist/commands/notes/repo/write.js

@@ -0,0 +1,251 @@
+// Note writes: create, metadata update, updatability checks, and soft delete.
+import { DinoxError } from '../../../utils/errors.js';
+import { nowIsoUtc } from '../../../utils/time.js';
+import { deriveImageDetailFromContentJson } from '../../todo/contentModel.js';
+import { normalizeLookupKey, parseStoredTags, parseZettelBoxIds, } from './shared.js';
+export async function createNote(db, input) {
+    const userId = input.userId.trim();
+    if (!userId) {
+        throw new DinoxError('userId is required to create a note');
+    }
+    const now = nowIsoUtc();
+    const contentJson = JSON.stringify(input.contentJson);
+    const tags = JSON.stringify(input.tags);
+    const zettelBoxes = JSON.stringify(input.zettelBoxIds);
+    const imageDetail = JSON.stringify(Array.isArray(input.imageDetail)
+        ? input.imageDetail
+        : deriveImageDetailFromContentJson(input.contentJson, input.id));
+    const columns = await db.getAll('PRAGMA table_info(c_note)', []);
+    const columnNames = new Set(columns
+        .map((row) => row.name?.trim().toLowerCase() ?? '')
+        .filter((name) => name.length > 0));
+    const userColumns = [];
+    if (columnNames.has('user_id')) {
+        userColumns.push('user_id');
+    }
+    if (columnNames.has('user_no')) {
+        userColumns.push('user_no');
+    }
+    if (userColumns.length === 0) {
+        throw new DinoxError('c_note table is missing both user_id and user_no columns');
+    }
+    if (!columnNames.has('type')) {
+        throw new DinoxError('c_note table is missing type column');
+    }
+    const requiredColumns = [
+        'id',
+        'title',
+        'type',
+        'content_md',
+        'content_json',
+        'content_text',
+        'tags',
+        'zettel_boxes',
+        'created_at',
+        'updated_at',
+        'is_del',
+        'version',
+    ];
+    const missingRequired = requiredColumns.filter((name) => !columnNames.has(name));
+    if (missingRequired.length > 0) {
+        throw new DinoxError(`c_note table is missing required columns: ${missingRequired.join(', ')}`);
+    }
+    const fullInsertEntries = [
+        ['id', input.id],
+        ['title', input.title],
+        ['type', input.noteType],
+        ['user_no', userId],
+        ['user_id', userId],
+        ['created_at', now],
+        ['updated_at', now],
+        ['is_del', 0],
+        ['status', 0],
+        ['version', 1],
+        ['content', ''],
+        ['content_json', contentJson],
+        ['content_text', input.contentText],
+        ['content_md', input.contentMd],
+        ['summary', ''],
+        ['tags', tags],
+        ['zettel_boxes', zettelBoxes],
+        ['images', '[]'],
+        ['files', '[]'],
+        ['audios', '[]'],
+        ['audio_detail', '{}'],
+        ['image_detail', imageDetail],
+        ['source', ''],
+        ['resource_id', null],
+        ['note_ids', '[]'],
+        ['extra_data', '{}'],
+        ['properties', null],
+        ['is_pub', 0],
+        ['format_type', ''],
+        ['comments', '[]'],
+        ['is_top', 0],
+        ['pinned_at', '1997-01-01T00:00:00.000Z'],
+        ['starred_at', null],
+        ['chat_context', '{}'],
+        ['bid_links', '[]'],
+    ];
+    const insertEntries = fullInsertEntries.filter(([column]) => columnNames.has(column));
+    const insertColumns = insertEntries.map(([column]) => column);
+    const placeholders = insertEntries.map(() => '?').join(', ');
+    const params = insertEntries.map(([, value]) => value);
+    await db.execute(`
+    INSERT INTO c_note (
+      ${insertColumns.join(', ')}
+    ) VALUES (${placeholders})
+    `, params);
+    return { id: input.id };
+}
+function normalizeDistinctStrings(values) {
+    return Array.from(new Set(values
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)));
+}
+function sameTagSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const leftKeys = left.map(normalizeLookupKey).sort();
+    const rightKeys = right.map(normalizeLookupKey).sort();
+    return leftKeys.every((value, index) => value === rightKeys[index]);
+}
+function sameStringSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const leftSorted = [...left].sort();
+    const rightSorted = [...right].sort();
+    return leftSorted.every((value, index) => value === rightSorted[index]);
+}
+export async function updateNote(db, input) {
+    const id = input.id.trim();
+    if (!id) {
+        throw new DinoxError('Note id is required');
+    }
+    const shouldUpdateTags = Array.isArray(input.tags);
+    const shouldUpdateBoxes = Array.isArray(input.zettelBoxIds);
+    const shouldUpdateStarred = typeof input.starred === 'boolean';
+    if (!shouldUpdateTags && !shouldUpdateBoxes && !shouldUpdateStarred) {
+        throw new DinoxError('At least one field is required: tags, boxes, or starred');
+    }
+    const existing = await db.getOptional(`
+    SELECT id, tags, zettel_boxes, is_del, starred_at
+    FROM c_note
+    WHERE id = ?
+    `, [id]);
+    if (!existing) {
+        throw new DinoxError(`Note not found: ${id}`);
+    }
+    if (typeof existing.is_del === 'number' && existing.is_del !== 0) {
+        throw new DinoxError(`Note has been deleted: ${id}`);
+    }
+    const currentTags = parseStoredTags(existing.tags);
+    const currentZettelBoxIds = parseZettelBoxIds(existing.zettel_boxes);
+    const currentStarred = existing.starred_at !== null;
+    const nextTags = shouldUpdateTags ? normalizeDistinctStrings(input.tags) : currentTags;
+    const nextZettelBoxIds = shouldUpdateBoxes ? normalizeDistinctStrings(input.zettelBoxIds) : currentZettelBoxIds;
+    const nextStarred = shouldUpdateStarred ? input.starred : currentStarred;
+    const tagsChanged = shouldUpdateTags && !sameTagSet(currentTags, nextTags);
+    const boxesChanged = shouldUpdateBoxes && !sameStringSet(currentZettelBoxIds, nextZettelBoxIds);
+    const starredChanged = shouldUpdateStarred && currentStarred !== nextStarred;
+    if (!tagsChanged && !boxesChanged && !starredChanged) {
+        return {
+            id,
+            updated: false,
+            changed: [],
+            tags: currentTags,
+            zettelBoxIds: currentZettelBoxIds,
+            is_starred: currentStarred,
+        };
+    }
+    const setParts = [];
+    const params = [];
+    if (tagsChanged) {
+        setParts.push('tags = ?');
+        params.push(JSON.stringify(nextTags));
+    }
+    if (boxesChanged) {
+        setParts.push('zettel_boxes = ?');
+        params.push(JSON.stringify(nextZettelBoxIds));
+    }
+    if (starredChanged) {
+        setParts.push('starred_at = ?');
+    }
+    const updatedAt = nowIsoUtc();
+    if (starredChanged) {
+        params.push(nextStarred ? updatedAt : null);
+    }
+    setParts.push('updated_at = ?');
+    params.push(updatedAt);
+    setParts.push('version = COALESCE(version, 0) + 1');
+    params.push(id);
+    await db.execute(`
+    UPDATE c_note
+    SET ${setParts.join(',\n        ')}
+    WHERE id = ?
+    `, params);
+    return {
+        id,
+        updated: true,
+        changed: [
+            ...(tagsChanged ? ['tags'] : []),
+            ...(boxesChanged ? ['boxes'] : []),
+            ...(starredChanged ? ['is_starred'] : []),
+        ],
+        tags: nextTags,
+        zettelBoxIds: nextZettelBoxIds,
+        is_starred: nextStarred,
+    };
+}
+export async function assertNotesUpdatable(db, noteIds) {
+    const ids = Array.from(new Set(noteIds
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (ids.length === 0) {
+        throw new DinoxError('At least one note id is required');
+    }
+    const existing = new Map();
+    const chunkSize = 500;
+    for (let index = 0; index < ids.length; index += chunkSize) {
+        const batch = ids.slice(index, index + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT id, is_del
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim();
+            if (!id) {
+                continue;
+            }
+            existing.set(id, row.is_del ?? null);
+        }
+    }
+    const missing = ids.filter((id) => !existing.has(id));
+    if (missing.length > 0) {
+        throw new DinoxError(`Notes not found: ${missing.join(', ')}`);
+    }
+    const deleted = ids.filter((id) => {
+        const isDel = existing.get(id);
+        return typeof isDel === 'number' && isDel !== 0;
+    });
+    if (deleted.length > 0) {
+        throw new DinoxError(`Notes have been deleted: ${deleted.join(', ')}`);
+    }
+}
+export async function softDeleteNote(db, id) {
+    const existing = await db.getOptional('SELECT id FROM c_note WHERE id = ?', [id]);
+    if (!existing) {
+        throw new DinoxError(`Note not found: ${id}`);
+    }
+    await db.execute(`
+    UPDATE c_note
+    SET is_del = 1,
+        updated_at = ?,
+        version = COALESCE(version, 0) + 1
+    WHERE id = ?
+    `, [nowIsoUtc(), id]);
+}

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

@@ -1,186 +1,7 @@
-import type { AbstractPowerSyncDatabase } from '@powersync/common';
-export type NoteRow = {
-    id: string;
-    title: string | null;
-    content_md: string | null;
-    content_json: string | null;
-    content_text: string | null;
-    summary: string | null;
-    zettel_boxes: string | null;
-    tags: string | null;
-    created_at: string | null;
-    updated_at: string | null;
-    is_del: number | null;
-    starred_at: string | null;
-    is_starred: number | null;
-    version: number | null;
-};
-type SearchNotesOptions = {
-    includeDeleted: boolean;
-    starred?: boolean;
-    tagsExpression?: string;
-    createdAtFrom?: string;
-    createdAtTo?: string;
-    zettelBoxIds?: string[];
-    matchEmptyZettelBoxes?: boolean;
-    sqlExpression?: string;
-};
-export type SearchedNote = {
-    id: string;
-    title: string;
-    summary: string;
-    tags: string[];
-    created_at: string | null;
-    starred_at: string | null;
-    is_starred: boolean;
-    zettel_boxes: string[];
-};
-export type NoteDetail = {
-    id: string;
-    created_at: string | null;
-    updated_at: string | null;
-    title: string | null;
-    type: string | null;
-    source: string | null;
-    tags: string[];
-    is_del: number | null;
-    is_pub: boolean;
-    properties: Record<string, unknown>;
-    starred_at: string | null;
-    is_starred: boolean;
-    content_md: string | null;
-    content_text: string | null;
-    content_json: unknown;
-    zettel_boxes: string[];
-};
-export type NoteExportItem = {
-    id: string;
-    created_at: string | null;
-    updated_at: string | null;
-    title: string | null;
-    type: string | null;
-    source: string | null;
-    summary: string | null;
-    tags: string[];
-    is_del: number | null;
-    is_pub: boolean;
-    properties: Record<string, unknown>;
-    starred_at: string | null;
-    is_starred: boolean;
-    content_md: string;
-    content_text: string | null;
-    content_json: unknown;
-    box_ids: string[];
-    boxes: string[];
-};
-export type NoteContext = {
-    id: string;
-    title: string;
-    summary: string;
-    tags: string[];
-    created_at: string | null;
-    updated_at: string | null;
-    is_del: number | null;
-    starred_at: string | null;
-    is_starred: boolean;
-    zettel_boxes: string[];
-    links: {
-        backlinks: number;
-        outlinks: number;
-    };
-};
-export type NotePreview = {
-    id: string;
-    title: string;
-    requested_lines: number;
-    total_lines: number;
-    returned_lines: number;
-    truncated: boolean;
-    preview: string;
-    updated_at: string | null;
-};
-export type UpdateNoteResult = {
-    id: string;
-    updated: boolean;
-    changed: string[];
-    tags: string[];
-    zettelBoxIds: string[];
-    is_starred: boolean;
-};
-/**
- * JSON-safe note-search request. Box *names/paths* are carried (not resolved ids) so the
- * same payload can be executed either in-process or sent to the daemon over the wire;
- * id resolution happens inside {@link executeNoteSearch} against whichever db runs it.
- */
-export type NoteSearchExecuteParams = {
-    keyword: string;
-    includeDeleted: boolean;
-    tagsExpression?: string;
-    createdAtFrom?: string;
-    createdAtTo?: string;
-    starred?: boolean;
-    boxValues: string[];
-    matchEmptyZettelBoxes: boolean;
-    sqlExpression?: string;
-    limit?: number;
-    offset?: number;
-};
-export type NoteSearchExecuteResult = {
-    rows: SearchedNote[];
-    totalCount: number;
-    /** Resolved zettel-box ids, surfaced so callers can echo them in response metadata. */
-    zettelBoxIds: string[];
-};
-/**
- * Resolve box names to ids and run the note search. Shared by the local command path and
- * the daemon RPC handler so both produce identical results from one implementation.
- */
-export declare function executeNoteSearch(db: AbstractPowerSyncDatabase, params: NoteSearchExecuteParams): Promise<NoteSearchExecuteResult>;
-export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
-type SearchNotesPageOptions = SearchNotesOptions & {
-    limit?: number;
-    offset?: number;
-};
-type SearchNotesPageResult = {
-    rows: SearchedNote[];
-    totalCount: number;
-};
-export declare function searchNotesPage(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesPageOptions): Promise<SearchNotesPageResult>;
-export declare function parseZettelBoxIds(raw: string | null): string[];
-export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
-export declare function getNoteContext(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContext | null>;
-export declare function getNotePreview(db: AbstractPowerSyncDatabase, id: string, requestedLines: number): Promise<NotePreview | null>;
-export declare function getNoteDetails(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteDetail[]>;
-export declare function getNoteDetail(db: AbstractPowerSyncDatabase, id: string): Promise<NoteDetail | null>;
-export declare function getNoteExportItems(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteExportItem[]>;
-export declare function createNote(db: AbstractPowerSyncDatabase, input: {
-    id: string;
-    title: string;
-    noteType: 'note' | 'crawl';
-    contentMd: string;
-    contentText: string;
-    contentJson: unknown;
-    tags: string[];
-    zettelBoxIds: string[];
-    userId: string;
-    imageDetail?: unknown[];
-}): Promise<{
-    id: string;
-}>;
-export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
-export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
-export declare function validateTagsForBulk(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
-export declare function parseStoredTags(raw: string | null): string[];
-export declare function updateNote(db: AbstractPowerSyncDatabase, input: {
-    id: string;
-    tags?: string[];
-    zettelBoxIds?: string[];
-    starred?: boolean;
-}): Promise<UpdateNoteResult>;
-export declare function assertNotesUpdatable(db: AbstractPowerSyncDatabase, noteIds: string[]): Promise<void>;
-export declare function resolveZettelBoxIdsForCreate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
-export declare function resolveZettelBoxIdsForSearch(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
-export declare function resolveZettelBoxIdsForUpdate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
-export declare function resolveZettelBoxIdsForBulk(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
-export declare function softDeleteNote(db: AbstractPowerSyncDatabase, id: string): Promise<void>;
-export {};
+export { parseStoredTags, parseZettelBoxIds, } from './repo/shared.js';
+export type { NoteContext, NoteDetail, NoteExportItem, NotePreview, NoteRow, SearchedNote, UpdateNoteResult, } from './repo/shared.js';
+export { executeNoteSearch, searchNotes, searchNotesPage, } from './repo/search.js';
+export type { NoteSearchExecuteParams, NoteSearchExecuteResult, } from './repo/search.js';
+export { getNote, getNoteContext, getNoteDetail, getNoteDetails, getNoteExportItems, getNotePreview, } from './repo/read.js';
+export { assertNotesUpdatable, createNote, softDeleteNote, updateNote, } from './repo/write.js';
+export { resolveZettelBoxIdsForBulk, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, validateTagsForBulk, validateTagsForCreate, validateTagsForUpdate, } from './repo/resolve.js';