@dinoxx/dinox-cli 1.1.0 → 2.0.0

package/dist/powersync/schema/storage.js

@@ -1,24 +1 @@
-import { column, Table } from '@powersync/common';
-export const c_storage = new Table({
-    id: column.text,
-    user_id: column.text,
-    alias_name: column.text,
-    protocol: column.text,
-    provider: column.text,
-    is_active: column.integer,
-    sort_rank: column.integer,
-    endpoint: column.text,
-    bucket: column.text,
-    region: column.text,
-    access_key_id: column.text,
-    secret_access_key: column.text,
-    force_path_style: column.integer,
-    path_prefix: column.text,
-    custom_domain: column.text,
-    legacy_domains: column.text,
-    is_private: column.integer,
-    extra_config: column.text,
-    created_at: column.text,
-    updated_at: column.text,
-    deleted_at: column.text,
-});
+export { c_storage } from './electronCanonical.js';

package/dist/powersync/schema/tags.d.ts

@@ -1,37 +1 @@
-import { Table } from '@powersync/common';
-export declare const c_tag: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    tags: import("@powersync/common").BaseColumnType<string | null>;
-    insert_at: import("@powersync/common").BaseColumnType<string | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    update_at: import("@powersync/common").BaseColumnType<string | null>;
-    user_id: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-    favorite_tags: import("@powersync/common").BaseColumnType<string | null>;
-}>;
-export declare const c_tag_node: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    user_id: import("@powersync/common").BaseColumnType<string | null>;
-    emoji: import("@powersync/common").BaseColumnType<string | null>;
-    full_path: import("@powersync/common").BaseColumnType<string | null>;
-    path_key: import("@powersync/common").BaseColumnType<string | null>;
-    parent_id: import("@powersync/common").BaseColumnType<string | null>;
-    depth: import("@powersync/common").BaseColumnType<number | null>;
-    is_actual: import("@powersync/common").BaseColumnType<number | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-    created_at: import("@powersync/common").BaseColumnType<string | null>;
-    updated_at: import("@powersync/common").BaseColumnType<string | null>;
-    meta: import("@powersync/common").BaseColumnType<string | null>;
-}>;
-export declare const c_tag_preference: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    user_id: import("@powersync/common").BaseColumnType<string | null>;
-    tag_id: import("@powersync/common").BaseColumnType<string | null>;
-    is_favorite: import("@powersync/common").BaseColumnType<number | null>;
-    is_expanded: import("@powersync/common").BaseColumnType<number | null>;
-    pinned_at: import("@powersync/common").BaseColumnType<string | null>;
-    sort_rank: import("@powersync/common").BaseColumnType<number | null>;
-    pinned_rank: import("@powersync/common").BaseColumnType<number | null>;
-    created_at: import("@powersync/common").BaseColumnType<string | null>;
-    updated_at: import("@powersync/common").BaseColumnType<string | null>;
-}>;
+export { c_tag_node, c_tag_preference } from './electronCanonical.js';

package/dist/powersync/schema/tags.js

@@ -1,37 +1 @@
-import { column, Table } from '@powersync/common';
-export const c_tag = new Table({
-    id: column.text,
-    tags: column.text,
-    insert_at: column.text,
-    extra_data: column.text,
-    update_at: column.text,
-    user_id: column.text,
-    is_del: column.integer,
-    favorite_tags: column.text,
-});
-export const c_tag_node = new Table({
-    id: column.text,
-    user_id: column.text,
-    emoji: column.text,
-    full_path: column.text,
-    path_key: column.text,
-    parent_id: column.text,
-    depth: column.integer,
-    is_actual: column.integer,
-    is_del: column.integer,
-    created_at: column.text,
-    updated_at: column.text,
-    meta: column.text,
-});
-export const c_tag_preference = new Table({
-    id: column.text,
-    user_id: column.text,
-    tag_id: column.text,
-    is_favorite: column.integer,
-    is_expanded: column.integer,
-    pinned_at: column.text,
-    sort_rank: column.integer,
-    pinned_rank: column.integer,
-    created_at: column.text,
-    updated_at: column.text,
-});
+export { c_tag_node, c_tag_preference } from './electronCanonical.js';

package/dist/powersync/syncGate.d.ts

@@ -1,6 +1,24 @@
-import type { SyncStatusOptions } from '@powersync/common';
+import type { SyncStatus } from '@powersync/common';
+/**
+ * Plain copy of the PowerSync sync status, reported as `status.raw` in JSON output.
+ * Keeps the 1.x `SyncStatusOptions` shape (PowerSync 2 made SyncStatus an interface
+ * and changed its toJSON() to an internal format).
+ */
+export type SyncStatusRaw = {
+    connected?: boolean;
+    connecting?: boolean;
+    hasSynced?: boolean;
+    lastSyncedAt?: Date;
+    dataFlow?: {
+        downloading?: boolean;
+        uploading?: boolean;
+        downloadError?: Error;
+        uploadError?: Error;
+    };
+    priorityStatusEntries?: SyncStatus['priorityStatusEntries'];
+};
 import { DinoxError } from '../utils/errors.js';
-export type SyncGateFailureReason = 'offline' | 'first-sync-timeout' | 'checkpoint-timeout' | 'data-flow-timeout' | 'not-connected' | 'not-synced' | 'download-error';
+export type SyncGateFailureReason = 'offline' | 'first-sync-timeout' | 'checkpoint-timeout' | 'data-flow-timeout' | 'index-timeout' | 'not-connected' | 'not-synced' | 'download-error';
 export type SyncGateResult = {
     ok: boolean;
     reasons: SyncGateFailureReason[];
@@ -9,6 +27,7 @@ export type SyncGateInput = {
     offline: boolean;
     firstSyncStale: boolean;
     idle: boolean;
+    indexComplete?: boolean;
     recentSync?: boolean;
     status: {
         connected: boolean;
@@ -19,7 +38,7 @@ export type SyncGateInput = {
                 message: string;
             };
         };
-        raw?: SyncStatusOptions;
+        raw?: SyncStatusRaw;
     };
 };
 export declare function evaluateSyncGate(input: SyncGateInput): SyncGateResult;

package/dist/powersync/syncGate.js

@@ -16,6 +16,9 @@ export function evaluateSyncGate(input) {
     if (!input.idle) {
         reasons.push('data-flow-timeout');
     }
+    if (input.indexComplete === false) {
+        reasons.push('index-timeout');
+    }
     if (!input.status.connected) {
         reasons.push('not-connected');
     }
@@ -37,6 +40,6 @@ export function createSyncRequiredError(gate, details) {
             reasons: gate.reasons,
             ...(details !== undefined ? { status: details } : {}),
         },
-        suggestion: 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.',
+        suggestion: 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.',
     });
 }

package/dist/powersync/syncPass.d.ts

@@ -2,6 +2,8 @@ import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import { type NoteTokenIndexResult } from './tokenIndex.js';
 export type SyncPassResult = {
     idle: boolean;
+    downloadIdle: boolean;
+    uploadIdle: boolean;
     tokenIndex: NoteTokenIndexResult;
 };
 export declare function runSingleSyncPass(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<SyncPassResult>;

package/dist/powersync/syncPass.js

@@ -1,10 +1,21 @@
-import { waitForIdleDataFlow } from './runtime.js';
+import { createTimeoutSignal } from '../utils/abort.js';
+import { getStatusSnapshot, waitForDownloadIdle } from './runtime.js';
 import { syncNoteTokenIndex } from './tokenIndex.js';
 export async function runSingleSyncPass(db, timeoutMs) {
-    const idle = await waitForIdleDataFlow(db, Math.min(timeoutMs, 60_000));
-    const tokenIndex = await syncNoteTokenIndex(db);
+    const deadline = Date.now() + Math.max(1, timeoutMs);
+    const remainingMs = () => Math.max(0, deadline - Date.now());
+    const downloadIdle = await waitForDownloadIdle(db, Math.max(1, Math.min(remainingMs(), 60_000)));
+    const indexTimeoutMs = remainingMs();
+    const timeout = indexTimeoutMs > 0 ? createTimeoutSignal(indexTimeoutMs) : null;
+    const tokenIndex = await syncNoteTokenIndex(db, {
+        signal: timeout?.signal ?? AbortSignal.abort(),
+    }).finally(() => timeout?.cancel());
+    const status = getStatusSnapshot(db);
+    const uploadIdle = !status.dataFlowStatus.uploading;
     return {
-        idle,
+        idle: downloadIdle && uploadIdle,
+        downloadIdle,
+        uploadIdle,
         tokenIndex,
     };
 }

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;
@@ -23,6 +24,7 @@ export declare function syncNoteTokenIndex(db: AbstractPowerSyncDatabase, option
     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,23 +55,40 @@ export async function syncNoteTokenIndex(db, options) {
             break;
         }
         for (const row of rows) {
+            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 };
     }
-    await reconcileSkippedRows(db, result, batchSize, nowIso, tokenize);
+    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
@@ -154,8 +176,11 @@ async function indexNoteRow(db, row, result, nowIso, tokenize) {
     }
     return sortKey;
 }
-async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
+async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal) {
     while (true) {
+        if (signal?.aborted) {
+            return false;
+        }
         const rows = await db.getAll(`
       SELECT
         n.id,
@@ -180,10 +205,16 @@ async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
             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
@@ -195,11 +226,22 @@ async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
             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 {

package/dist/powersync/uploader.d.ts

@@ -1,8 +1,22 @@
+import { type CrudTransaction } from '@powersync/common';
 import type { UploadHandler } from './connector.js';
+export type UploadOperation = {
+    op_id: number;
+    op: 'PUT' | 'PATCH' | 'DELETE';
+    type: string;
+    id: string;
+    tx_id?: number;
+    data?: Record<string, unknown>;
+    old?: Record<string, unknown>;
+    old_sha256?: Record<string, string>;
+    metadata?: string;
+};
+type CrudOperation = CrudTransaction['crud'][number];
+export declare function toUploadOperation(op: CrudOperation): UploadOperation;
 export declare function createPowerSyncUploadHandler(options: {
     authorization: string;
     uploadBaseUrl: string;
-    uploadV4Path: string;
-    uploadV2Path: string;
+    uploadPath: string;
     timeoutMs?: number;
 }): UploadHandler;
+export {};