@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/powersync/tokenIndex.d.ts

@@ -1,5 +1,6 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 export type NoteTokenIndexResult = {
+    complete: boolean;
     scanned: number;
     reindexed: number;
     skipped: number;
@@ -10,8 +11,20 @@ export type NoteTokenIndexResult = {
         id: string;
     };
 };
+export type NoteTokenIndexInspection = {
+    notes: number;
+    ftsRows: number;
+    metaRows: number;
+    missingRows: number;
+    extraRows: number;
+    drift: number;
+    ftsAvailable: boolean;
+};
 export declare function syncNoteTokenIndex(db: AbstractPowerSyncDatabase, options?: {
     batchSize?: number;
     nowIso?: () => string;
     tokenize?: (text: string, limit?: number) => string[];
+    signal?: AbortSignal;
 }): Promise<NoteTokenIndexResult>;
+export declare function inspectNoteTokenIndex(db: AbstractPowerSyncDatabase): Promise<NoteTokenIndexInspection>;
+export declare function rebuildNoteTokenIndex(db: AbstractPowerSyncDatabase, options?: Parameters<typeof syncNoteTokenIndex>[1]): Promise<NoteTokenIndexResult>;

package/dist/powersync/tokenIndex.js

@@ -9,22 +9,27 @@ export async function syncNoteTokenIndex(db, options) {
     const batchSize = Math.max(1, Math.trunc(options?.batchSize ?? DEFAULT_BATCH_SIZE));
     const nowIso = options?.nowIso ?? nowIsoUtc;
     const tokenize = options?.tokenize ?? tokenizeWithJieba;
+    const signal = options?.signal;
+    if (signal?.aborted) {
+        return createIndexResult('', '', false);
+    }
     await ensureFtsTable(db);
+    if (signal?.aborted) {
+        return createIndexResult('', '', false);
+    }
     const state = await ensureIndexState(db, nowIso);
     let cursorUpdatedAt = state.cursor_updated_at ?? '';
     let cursorId = state.cursor_id ?? '';
-    const result = {
-        scanned: 0,
-        reindexed: 0,
-        skipped: 0,
-        removed: 0,
-        ftsRowsUpserted: 0,
-        cursor: {
-            updatedAt: cursorUpdatedAt,
-            id: cursorId,
-        },
-    };
+    const result = createIndexResult(cursorUpdatedAt, cursorId, true);
+    if (signal?.aborted) {
+        result.complete = false;
+        return result;
+    }
     while (true) {
+        if (signal?.aborted) {
+            result.complete = false;
+            return result;
+        }
         const rows = await db.getAll(`
       SELECT
         id,
@@ -50,43 +55,194 @@ export async function syncNoteTokenIndex(db, options) {
             break;
         }
         for (const row of rows) {
-            result.scanned += 1;
-            const sortKey = noteSortKey(row);
-            const bodySource = selectIndexBodyText(row);
-            const sourceHash = createSourceHash(row, bodySource);
-            const meta = await db.getOptional(`
-        SELECT source_hash
-        FROM note_local_index_meta
-        WHERE id = ?
-        `, [row.id]);
-            if (meta?.source_hash === sourceHash) {
-                result.skipped += 1;
-            }
-            else {
-                const changed = await reindexOneNoteFts(db, row, sourceHash, bodySource, nowIso, tokenize);
-                if (changed.upserted) {
-                    result.reindexed += 1;
-                    result.ftsRowsUpserted += 1;
-                }
-                else {
-                    result.removed += 1;
-                }
+            if (signal?.aborted) {
+                result.complete = false;
+                await updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso);
+                result.cursor = { updatedAt: cursorUpdatedAt, id: cursorId };
+                return result;
             }
+            const sortKey = await indexNoteRow(db, row, result, nowIso, tokenize);
             cursorUpdatedAt = sortKey;
             cursorId = row.id;
         }
-        await db.execute(`
-      UPDATE note_local_index_state
-      SET cursor_updated_at = ?, cursor_id = ?, updated_at = ?
-      WHERE id = ?
-      `, [cursorUpdatedAt, cursorId, nowIso(), INDEX_STATE_ID]);
+        await updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso);
+        result.cursor = { updatedAt: cursorUpdatedAt, id: cursorId };
     }
+    result.complete = await reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal);
     result.cursor = {
         updatedAt: cursorUpdatedAt,
         id: cursorId,
     };
     return result;
 }
+function createIndexResult(cursorUpdatedAt, cursorId, complete) {
+    return {
+        complete,
+        scanned: 0,
+        reindexed: 0,
+        skipped: 0,
+        removed: 0,
+        ftsRowsUpserted: 0,
+        cursor: {
+            updatedAt: cursorUpdatedAt,
+            id: cursorId,
+        },
+    };
+}
+export async function inspectNoteTokenIndex(db) {
+    const notes = await countRows(db, `
+    SELECT COUNT(*) AS count
+    FROM c_note
+    WHERE is_del IS NULL OR is_del = 0
+    `);
+    const metaRows = await countRowsIfAvailable(db, `
+    SELECT COUNT(*) AS count
+    FROM note_local_index_meta
+    `);
+    const ftsRows = await countRowsIfAvailable(db, `
+    SELECT COUNT(DISTINCT note_id) AS count
+    FROM ${NOTE_LOCAL_FTS_TABLE}
+    `);
+    if (ftsRows === null) {
+        return {
+            notes,
+            ftsRows: 0,
+            metaRows: metaRows ?? 0,
+            missingRows: notes,
+            extraRows: 0,
+            drift: notes,
+            ftsAvailable: false,
+        };
+    }
+    const missingRows = await countRows(db, `
+    SELECT COUNT(*) AS count
+    FROM c_note n
+    LEFT JOIN ${NOTE_LOCAL_FTS_TABLE} f ON f.note_id = n.id
+    WHERE (n.is_del IS NULL OR n.is_del = 0)
+      AND f.note_id IS NULL
+    `);
+    const extraRows = await countRows(db, `
+    SELECT COUNT(DISTINCT f.note_id) AS count
+    FROM ${NOTE_LOCAL_FTS_TABLE} f
+    LEFT JOIN c_note n
+      ON n.id = f.note_id
+      AND (n.is_del IS NULL OR n.is_del = 0)
+    WHERE n.id IS NULL
+    `);
+    return {
+        notes,
+        ftsRows,
+        metaRows: metaRows ?? 0,
+        missingRows,
+        extraRows,
+        drift: missingRows + extraRows,
+        ftsAvailable: true,
+    };
+}
+export async function rebuildNoteTokenIndex(db, options) {
+    await ensureFtsTable(db);
+    await db.execute(`DELETE FROM ${NOTE_LOCAL_FTS_TABLE}`, []);
+    await db.execute('DELETE FROM note_local_index_meta', []);
+    await db.execute('DELETE FROM note_local_index_state WHERE id = ?', [INDEX_STATE_ID]);
+    return syncNoteTokenIndex(db, options);
+}
+async function indexNoteRow(db, row, result, nowIso, tokenize) {
+    result.scanned += 1;
+    const sortKey = noteSortKey(row);
+    const bodySource = selectIndexBodyText(row);
+    const sourceHash = createSourceHash(row, bodySource);
+    const deleted = isDeleted(row.is_del);
+    const meta = await db.getOptional(`
+    SELECT source_hash
+    FROM note_local_index_meta
+    WHERE id = ?
+    `, [row.id]);
+    if (meta?.source_hash === sourceHash) {
+        await db.execute(`
+      UPDATE note_local_index_meta
+      SET note_updated_at = ?, is_del = ?, indexed_at = ?
+      WHERE id = ?
+      `, [sortKey, deleted ? 1 : 0, nowIso(), row.id]);
+        result.skipped += 1;
+        return sortKey;
+    }
+    const changed = await reindexOneNoteFts(db, row, sourceHash, bodySource, nowIso, tokenize);
+    if (changed.upserted) {
+        result.reindexed += 1;
+        result.ftsRowsUpserted += 1;
+    }
+    else {
+        result.removed += 1;
+    }
+    return sortKey;
+}
+async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal) {
+    while (true) {
+        if (signal?.aborted) {
+            return false;
+        }
+        const rows = await db.getAll(`
+      SELECT
+        n.id,
+        n.title,
+        n.content_md,
+        n.content_text,
+        n.tags,
+        n.created_at,
+        n.updated_at,
+        n.is_del,
+        n.version
+      FROM c_note n
+      LEFT JOIN note_local_index_meta m ON m.id = n.id
+      WHERE
+        m.id IS NULL
+        OR COALESCE(m.note_updated_at, '') <> COALESCE(n.updated_at, n.created_at, '')
+        OR COALESCE(m.is_del, 0) <> CASE WHEN n.is_del IS NOT NULL AND n.is_del <> 0 THEN 1 ELSE 0 END
+      ORDER BY COALESCE(n.updated_at, n.created_at, '') ASC, n.id ASC
+      LIMIT ?
+      `, [batchSize]);
+        if (rows.length === 0) {
+            break;
+        }
+        for (const row of rows) {
+            if (signal?.aborted) {
+                return false;
+            }
+            await indexNoteRow(db, row, result, nowIso, tokenize);
+        }
+    }
+    while (true) {
+        if (signal?.aborted) {
+            return false;
+        }
+        const rows = await db.getAll(`
+      SELECT m.id
+      FROM note_local_index_meta m
+      LEFT JOIN c_note n ON n.id = m.id
+      WHERE n.id IS NULL
+      LIMIT ?
+      `, [batchSize]);
+        if (rows.length === 0) {
+            break;
+        }
+        for (const row of rows) {
+            if (signal?.aborted) {
+                return false;
+            }
+            await db.execute(`DELETE FROM ${NOTE_LOCAL_FTS_TABLE} WHERE note_id = ?`, [row.id]);
+            await db.execute('DELETE FROM note_local_index_meta WHERE id = ?', [row.id]);
+            result.removed += 1;
+        }
+    }
+    return true;
+}
+async function updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso) {
+    await db.execute(`
+    UPDATE note_local_index_state
+    SET cursor_updated_at = ?, cursor_id = ?, updated_at = ?
+    WHERE id = ?
+    `, [cursorUpdatedAt, cursorId, nowIso(), INDEX_STATE_ID]);
+}
 async function ensureFtsTable(db) {
     try {
         await db.execute(`
@@ -105,6 +261,29 @@ async function ensureFtsTable(db) {
         throw new Error(`Failed to initialize FTS5 table (${NOTE_LOCAL_FTS_TABLE}): ${message}`);
     }
 }
+function isMissingLocalIndexTableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.toLowerCase().includes('no such table');
+}
+function normalizeCount(value) {
+    const parsed = Number(value ?? 0);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0;
+}
+async function countRows(db, sql, params = []) {
+    const row = await db.getOptional(sql, params);
+    return normalizeCount(row?.count);
+}
+async function countRowsIfAvailable(db, sql, params = []) {
+    try {
+        return await countRows(db, sql, params);
+    }
+    catch (error) {
+        if (isMissingLocalIndexTableError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
 async function ensureIndexState(db, nowIso) {
     const state = await db.getOptional(`
     SELECT cursor_updated_at, cursor_id

package/dist/powersync/uploader.js

@@ -1,16 +1,21 @@
 import { UpdateType } from '@powersync/common';
 import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
 import { toAuthorizationHeaderValue } from '../utils/authToken.js';
+import { sanitizeForTerminal } from '../utils/terminalSanitization.js';
 const FATAL_RESPONSE_CODES = [/^22...$/, /^23...$/, /^42501$/];
+const legacyUploadTargets = new Set();
 function shouldFallbackToLegacy(status) {
     return status === 404 || status === 405;
 }
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
 }
+function legacyUploadTargetKey(baseUrl, uploadV4Path) {
+    return `${normalizeBaseUrl(baseUrl)}${uploadV4Path}`;
+}
 async function readErrorBody(response) {
     const contentType = response.headers.get('content-type') ?? '';
-    const text = await response.text().catch(() => '');
+    const text = await response.text();
     if (contentType.includes('application/json')) {
         try {
             const json = JSON.parse(text);
@@ -43,17 +48,60 @@ function isFatalUploadError(error) {
     if (!error || typeof error !== 'object') {
         return false;
     }
-    const code = error.code;
-    return typeof code === 'string' && FATAL_RESPONSE_CODES.some(regex => regex.test(code));
+    const uploadError = error;
+    if (uploadError.fatal === true) {
+        return true;
+    }
+    return typeof uploadError.code === 'string'
+        && FATAL_RESPONSE_CODES.some(regex => regex.test(uploadError.code));
+}
+function createUnsupportedCrudOperationError(op) {
+    const error = new Error(`Unsupported PowerSync CRUD operation: ${String(op.op)} (${String(op.table)}:${String(op.id ?? '')})`);
+    error.name = 'PowerSyncUploadError';
+    error.code = 'UNSUPPORTED_CRUD_OPERATION';
+    error.fatal = true;
+    return error;
+}
+function summarizeCrudOperation(op) {
+    const opName = UpdateType[op.op] ?? String(op.op);
+    return {
+        id: String(op.id ?? ''),
+        op: opName,
+        table: String(op.table ?? ''),
+    };
+}
+function attachFatalContext(error, transaction, failedIndex) {
+    if (!isFatalUploadError(error)) {
+        return;
+    }
+    error.fatalContext = {
+        failedIndex,
+        operations: transaction.crud.map((op) => summarizeCrudOperation(op)),
+    };
+}
+function logFatalUploadFailure(error) {
+    const context = error.fatalContext;
+    if (!context) {
+        process.stderr.write(`${sanitizeForTerminal(`warning: fatal PowerSync upload error (${error.code ?? error.status ?? 'unknown'}); queued operations were retained.`)}\n`);
+        return;
+    }
+    const failedOperation = context.operations[context.failedIndex];
+    const failedOperationText = failedOperation
+        ? `${failedOperation.op}:${failedOperation.table}:${failedOperation.id || '(no-id)'}`
+        : `index ${context.failedIndex}`;
+    const succeededBeforeFailure = Math.min(context.failedIndex, context.operations.length);
+    const replayWarning = succeededBeforeFailure > 0
+        ? ` ${succeededBeforeFailure} earlier operation(s) already returned success and may be sent again on retry; the legacy upload endpoints do not provide a transaction-level acknowledgement.`
+        : '';
+    process.stderr.write(`${sanitizeForTerminal(`warning: fatal PowerSync upload error (${error.code ?? error.status ?? 'unknown'}) at ${failedOperationText}; PowerSync retained the entire ${context.operations.length}-operation transaction.${replayWarning}`)}\n`);
 }
 async function dispatchMutation(options) {
     const timeout = typeof options.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
         ? createTimeoutSignal(options.timeoutMs)
         : null;
     const requestSignal = mergeAbortSignals([options.signal, timeout?.signal]);
-    let response;
     try {
-        response = await fetch(options.url, {
+        const response = await fetch(options.url, {
             method: options.method,
             headers: {
                 Authorization: toAuthorizationHeaderValue(options.authorization),
@@ -62,6 +110,19 @@ async function dispatchMutation(options) {
             body: JSON.stringify(options.payload),
             signal: requestSignal,
         });
+        if (response.ok) {
+            await response.arrayBuffer();
+            return;
+        }
+        const body = await readErrorBody(response);
+        throw createUploadError({
+            status: response.status,
+            method: options.method,
+            url: options.url,
+            code: body.code,
+            message: body.message,
+            text: body.text,
+        });
     }
     catch (error) {
         if (timeout?.signal.aborted && !options.signal?.aborted) {
@@ -75,57 +136,50 @@ async function dispatchMutation(options) {
     finally {
         timeout?.cancel();
     }
-    if (response.ok) {
-        return;
-    }
-    const body = await readErrorBody(response);
-    throw createUploadError({
-        status: response.status,
-        method: options.method,
-        url: options.url,
-        code: body.code,
-        message: body.message,
-        text: body.text,
-    });
 }
 async function uploadTransaction(args) {
     const baseUrl = normalizeBaseUrl(args.uploadBaseUrl);
     const primaryUrl = `${baseUrl}${args.uploadV4Path}`;
     const fallbackUrl = `${baseUrl}${args.uploadV2Path}`;
-    for (const op of args.transaction.crud) {
+    const primaryKey = legacyUploadTargetKey(baseUrl, args.uploadV4Path);
+    const dispatchPutOrPatch = async (method, payload) => {
+        if (legacyUploadTargets.has(primaryKey)) {
+            await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method, payload, timeoutMs: args.timeoutMs });
+            return;
+        }
+        try {
+            await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method, payload, timeoutMs: args.timeoutMs });
+        }
+        catch (error) {
+            if (shouldFallbackToLegacy(error?.status)) {
+                legacyUploadTargets.add(primaryKey);
+                await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method, payload, timeoutMs: args.timeoutMs });
+                return;
+            }
+            throw error;
+        }
+    };
+    for (let index = 0; index < args.transaction.crud.length; index += 1) {
+        const op = args.transaction.crud[index];
         const record = { table: op.table, data: { ...(op.opData ?? {}), id: op.id } };
-        switch (op.op) {
-            case UpdateType.PUT:
-                try {
-                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PUT', payload: record, timeoutMs: args.timeoutMs });
-                }
-                catch (error) {
-                    if (shouldFallbackToLegacy(error?.status)) {
-                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PUT', payload: record, timeoutMs: args.timeoutMs });
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                break;
-            case UpdateType.PATCH:
-                try {
-                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PATCH', payload: record, timeoutMs: args.timeoutMs });
-                }
-                catch (error) {
-                    if (shouldFallbackToLegacy(error?.status)) {
-                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PATCH', payload: record, timeoutMs: args.timeoutMs });
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                break;
-            case UpdateType.DELETE:
-                await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'DELETE', payload: record, timeoutMs: args.timeoutMs });
-                break;
-            default:
-                break;
+        try {
+            switch (op.op) {
+                case UpdateType.PUT:
+                    await dispatchPutOrPatch('PUT', record);
+                    break;
+                case UpdateType.PATCH:
+                    await dispatchPutOrPatch('PATCH', record);
+                    break;
+                case UpdateType.DELETE:
+                    await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'DELETE', payload: record, timeoutMs: args.timeoutMs });
+                    break;
+                default:
+                    throw createUnsupportedCrudOperationError(op);
+            }
+        }
+        catch (error) {
+            attachFatalContext(error, args.transaction, index);
+            throw error;
         }
     }
 }
@@ -148,8 +202,9 @@ export function createPowerSyncUploadHandler(options) {
         }
         catch (error) {
             if (isFatalUploadError(error)) {
-                await transaction.complete();
-                return;
+                // v4/v2 acknowledge individual operations, so completing here would discard
+                // the failed suffix; retaining the transaction can replay an accepted prefix.
+                logFatalUploadFailure(error);
             }
             throw error;
         }

package/dist/utils/abort.js

@@ -1,10 +1,6 @@
 export function createTimeoutSignal(timeoutMs) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
-    // Best-effort: don't keep the process alive solely for the timeout.
-    if (typeof timer.unref === 'function') {
-        timer.unref();
-    }
     return {
         signal: controller.signal,
         cancel: () => clearTimeout(timer),

package/dist/utils/asyncRelease.d.ts

@@ -0,0 +1,2 @@
+export type AsyncRelease = () => Promise<void>;
+export declare function withAsyncRelease<T>(acquire: () => Promise<AsyncRelease>, run: () => Promise<T>): Promise<T>;

package/dist/utils/asyncRelease.js

@@ -0,0 +1,25 @@
+export async function withAsyncRelease(acquire, run) {
+    const release = await acquire();
+    let operationFailed = false;
+    let operationError;
+    let value;
+    try {
+        value = await run();
+    }
+    catch (error) {
+        operationFailed = true;
+        operationError = error;
+    }
+    try {
+        await release();
+    }
+    catch (error) {
+        if (!operationFailed) {
+            throw error;
+        }
+    }
+    if (operationFailed) {
+        throw operationError;
+    }
+    return value;
+}

package/dist/utils/bidlinkCanonicalization.js

@@ -151,6 +151,9 @@ export async function canonicalizeBidlinksInMarkdown(db, markdown, userId) {
         if (!resolvedId) {
             continue;
         }
+        if (nextMarkdown.slice(occurrence.startOffset, occurrence.endOffset) !== occurrence.raw) {
+            continue;
+        }
         const replacement = `[[${escapeBidlinkValue(occurrence.label)}|${escapeBidlinkValue(resolvedId)}]]`;
         nextMarkdown =
             nextMarkdown.slice(0, occurrence.startOffset) +

package/dist/utils/dryRun.d.ts

@@ -2,7 +2,7 @@ export type DryRunPreview = {
     dry_run: true;
     command: string;
     action: string;
-    risk: 'write' | 'high-risk-write';
+    risk: 'read' | 'write' | 'high-risk-write';
     summary: string;
     warnings?: string[];
     inputs?: Record<string, unknown>;

package/dist/utils/errors.d.ts

@@ -4,24 +4,38 @@ export type DinoxErrorOptions = {
     details?: unknown;
     code?: string;
     suggestion?: string;
+    suggestedAction?: SuggestedAction;
     recoverable?: boolean;
 };
+export type SuggestedAction = {
+    command: string;
+    reason: string;
+};
 export type StructuredErrorPayload = {
     name: string;
     code: string;
     message: string;
     recoverable: boolean;
+    exit_code: number;
+    cause?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
     suggestion?: string;
+    suggested_action?: SuggestedAction;
     details?: unknown;
     stack?: string;
 };
 export declare class DinoxError extends Error {
     readonly exitCode: number;
     readonly details?: unknown;
-    readonly code?: string;
+    readonly code: string;
     readonly suggestion?: string;
+    readonly suggestedAction?: SuggestedAction;
     readonly recoverable: boolean;
     constructor(message: string, options?: DinoxErrorOptions);
 }
 export declare function isDinoxError(error: unknown): error is DinoxError;
 export declare function buildStructuredErrorPayload(error: unknown, verbose: boolean): StructuredErrorPayload;
+export declare function exitCodeForErrorCode(code: string): number;