@dinoxx/dinox-cli 1.1.1 → 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,4 +1,22 @@
-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' | 'index-timeout' | 'not-connected' | 'not-synced' | 'download-error';
 export type SyncGateResult = {
@@ -20,7 +38,7 @@ export type SyncGateInput = {
                 message: string;
             };
         };
-        raw?: SyncStatusOptions;
+        raw?: SyncStatusRaw;
     };
 };
 export declare function evaluateSyncGate(input: SyncGateInput): SyncGateResult;

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 {};

package/dist/powersync/uploader.js

@@ -1,135 +1,164 @@
+import crypto from 'node:crypto';
 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;
+/**
+ * Uploads each PowerSync CRUD transaction as ONE request to the backend v6 batch
+ * endpoint (same contract as dinox-electron / dinox-web / dinox-app). The backend
+ * applies the batch atomically in arrival order and answers `applied` or
+ * `rejected`, so a transaction either lands whole or not at all.
+ */
+const NON_RETRYABLE_UPLOAD_HTTP_STATUSES = new Set([400, 409, 422]);
+// Pre-edit values longer than this travel as a SHA-256 so long note bodies are not
+// re-uploaded as conflict-detection bases; the backend hashes its stored text.
+const OLD_VALUE_HASH_THRESHOLD = 256;
+const UPLOAD_OMITTED_COLUMNS_BY_TABLE = new Map([
+    // The backend v6 tag-node mapper does not consume this local metadata column.
+    ['c_tag_node', new Set(['meta'])],
+    // Server-generated scheduled-task columns must not be echoed back.
+    ['c_scheduled_task', new Set(['last_run_at', 'last_run_id'])],
+]);
+const UPLOAD_REQUIRED_INSERT_DEFAULTS_BY_TABLE = new Map([
+    // PowerSync omits NULL values from PUT payloads, while the backend requires these.
+    ['c_note_template', { content: '', extra_data: '{}' }],
+]);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 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();
-    if (contentType.includes('application/json')) {
-        try {
-            const json = JSON.parse(text);
-            const code = json?.error?.code ?? json?.code;
-            const message = json?.error?.message ?? json?.message;
-            return {
-                code: typeof code === 'string' ? code : undefined,
-                message: typeof message === 'string' ? message : undefined,
-                text,
-            };
-        }
-        catch {
-            return { text };
-        }
-    }
-    return { text };
-}
-function createUploadError(args) {
-    const details = args.message ?? args.text;
-    const message = details
-        ? `PowerSync upload failed (${args.method} ${args.url}) [${args.status}]: ${details}`
-        : `PowerSync upload failed (${args.method} ${args.url}) [${args.status}]`;
+function createUploadError(message, extra = {}) {
     const error = new Error(message);
     error.name = 'PowerSyncUploadError';
-    error.code = args.code;
-    error.status = args.status;
+    error.code = extra.code;
+    error.status = extra.status;
+    error.fatal = extra.fatal;
     return error;
 }
-function isFatalUploadError(error) {
-    if (!error || typeof error !== 'object') {
-        return false;
-    }
-    const uploadError = error;
-    if (uploadError.fatal === true) {
-        return true;
+function toUploadOperationName(op) {
+    switch (op.op) {
+        case UpdateType.PUT:
+            return 'PUT';
+        case UpdateType.PATCH:
+            return 'PATCH';
+        case UpdateType.DELETE:
+            return 'DELETE';
+        default:
+            throw createUploadError(`Unsupported PowerSync CRUD operation: ${String(op.op)} (${String(op.table)}:${String(op.id ?? '')})`, { code: 'UNSUPPORTED_CRUD_OPERATION', fatal: 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 omitColumns(table, values) {
+    const omitted = UPLOAD_OMITTED_COLUMNS_BY_TABLE.get(table);
+    if (!omitted)
+        return values;
+    const next = { ...values };
+    for (const column of omitted)
+        delete next[column];
+    return next;
 }
-function summarizeCrudOperation(op) {
-    const opName = UpdateType[op.op] ?? String(op.op);
+/** `old` is the conflict-detection base (trackPrevious); long values move to `old_sha256`. */
+function compactPreviousValues(previous) {
+    if (!previous)
+        return {};
+    const old = {};
+    const oldSha256 = {};
+    for (const [column, value] of Object.entries(previous)) {
+        if (typeof value === 'string' && value.length > OLD_VALUE_HASH_THRESHOLD) {
+            oldSha256[column] = crypto.createHash('sha256').update(value, 'utf8').digest('hex');
+        }
+        else {
+            old[column] = value;
+        }
+    }
     return {
-        id: String(op.id ?? ''),
-        op: opName,
-        table: String(op.table ?? ''),
+        ...(Object.keys(old).length > 0 ? { old } : {}),
+        ...(Object.keys(oldSha256).length > 0 ? { old_sha256: oldSha256 } : {}),
     };
 }
-function attachFatalContext(error, transaction, failedIndex) {
-    if (!isFatalUploadError(error)) {
-        return;
+export function toUploadOperation(op) {
+    const name = toUploadOperationName(op);
+    const table = String(op.table);
+    let data = isRecord(op.opData) ? { ...op.opData } : undefined;
+    if (name === 'PUT') {
+        data ??= {};
+        for (const [column, value] of Object.entries(UPLOAD_REQUIRED_INSERT_DEFAULTS_BY_TABLE.get(table) ?? {})) {
+            if (data[column] == null)
+                data[column] = value;
+        }
     }
-    error.fatalContext = {
-        failedIndex,
-        operations: transaction.crud.map((op) => summarizeCrudOperation(op)),
+    return {
+        op_id: op.clientId,
+        op: name,
+        type: table,
+        id: String(op.id),
+        ...(op.transactionId !== undefined ? { tx_id: op.transactionId } : {}),
+        ...(data ? { data: omitColumns(table, data) } : {}),
+        // DELETE needs no base: deletes win (PowerSync default), nothing to compare.
+        ...(name === 'PATCH' ? compactPreviousValues(op.previousValues) : {}),
+        ...(op.metadata !== undefined ? { metadata: op.metadata } : {}),
     };
 }
-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;
+function isEmptyPatch(operation) {
+    return operation.op === 'PATCH' && (!operation.data || Object.keys(operation.data).length === 0);
+}
+function isUploadResponse(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.status !== 'applied' && value.status !== 'rejected')
+        return false;
+    return typeof value.operationCount === 'number' && Number.isFinite(value.operationCount);
+}
+async function readResponseBody(response) {
+    const text = await response.text();
+    try {
+        return { json: JSON.parse(text), text };
+    }
+    catch {
+        return { text };
     }
-    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)
+function errorDetails(json) {
+    if (!isRecord(json))
+        return {};
+    const nested = isRecord(json.error) ? json.error : json;
+    return {
+        code: typeof nested.code === 'string' ? nested.code : undefined,
+        message: typeof nested.message === 'string' ? nested.message : undefined,
+    };
+}
+async function postBatch(args) {
+    const timeout = typeof args.timeoutMs === 'number' && Number.isFinite(args.timeoutMs) && args.timeoutMs > 0
+        ? createTimeoutSignal(args.timeoutMs)
         : null;
-    const requestSignal = mergeAbortSignals([options.signal, timeout?.signal]);
     try {
-        const response = await fetch(options.url, {
-            method: options.method,
+        const response = await fetch(args.url, {
+            method: 'POST',
             headers: {
-                Authorization: toAuthorizationHeaderValue(options.authorization),
+                Authorization: toAuthorizationHeaderValue(args.authorization),
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify(options.payload),
-            signal: requestSignal,
+            body: JSON.stringify({ batch: args.batch }),
+            signal: mergeAbortSignals([timeout?.signal]),
         });
-        if (response.ok) {
-            await response.arrayBuffer();
-            return;
+        const body = await readResponseBody(response);
+        if (!response.ok) {
+            const details = errorDetails(body.json);
+            throw createUploadError(`PowerSync upload failed (POST ${args.url}) [${response.status}]: ${details.message ?? body.text}`, {
+                code: details.code ?? `HTTP_${response.status}`,
+                status: response.status,
+                fatal: NON_RETRYABLE_UPLOAD_HTTP_STATUSES.has(response.status),
+            });
         }
-        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,
-        });
+        if (!isUploadResponse(body.json)) {
+            throw createUploadError(`Invalid PowerSync v6 response from ${args.url}`);
+        }
+        return body.json;
     }
     catch (error) {
-        if (timeout?.signal.aborted && !options.signal?.aborted) {
-            const err = new Error(`PowerSync upload timed out (${options.method} ${options.url}) after ${options.timeoutMs}ms`);
-            err.name = 'PowerSyncUploadError';
-            err.status = 408;
-            throw err;
+        if (timeout?.signal.aborted) {
+            throw createUploadError(`PowerSync upload timed out (POST ${args.url}) after ${args.timeoutMs}ms`, { status: 408 });
         }
         throw error;
     }
@@ -137,76 +166,41 @@ async function dispatchMutation(options) {
         timeout?.cancel();
     }
 }
-async function uploadTransaction(args) {
-    const baseUrl = normalizeBaseUrl(args.uploadBaseUrl);
-    const primaryUrl = `${baseUrl}${args.uploadV4Path}`;
-    const fallbackUrl = `${baseUrl}${args.uploadV2Path}`;
-    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 } };
-        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;
-        }
-    }
+function describeOperation(operation) {
+    return operation ? `${operation.op}:${operation.type}:${operation.id}` : '(none)';
 }
 export function createPowerSyncUploadHandler(options) {
+    const url = `${normalizeBaseUrl(options.uploadBaseUrl)}${options.uploadPath}`;
     return async (database) => {
         const transaction = await database.getNextCrudTransaction();
         if (!transaction) {
             return;
         }
-        try {
-            await uploadTransaction({
-                transaction,
-                authorization: options.authorization,
-                uploadBaseUrl: options.uploadBaseUrl,
-                uploadV4Path: options.uploadV4Path,
-                uploadV2Path: options.uploadV2Path,
-                timeoutMs: options.timeoutMs,
-            });
+        // Redundant local updates can collapse into empty PATCHes; they carry no state.
+        const batch = transaction.crud.map(toUploadOperation).filter(op => !isEmptyPatch(op));
+        if (batch.length === 0) {
             await transaction.complete();
+            return;
+        }
+        let result;
+        try {
+            result = await postBatch({ url, authorization: options.authorization, batch, timeoutMs: options.timeoutMs });
         }
         catch (error) {
-            if (isFatalUploadError(error)) {
-                // v4/v2 acknowledge individual operations, so completing here would discard
-                // the failed suffix; retaining the transaction can replay an accepted prefix.
-                logFatalUploadFailure(error);
+            if (error.fatal) {
+                process.stderr.write(`${sanitizeForTerminal(`warning: PowerSync refused the ${batch.length}-operation upload (${error.code}); ` +
+                    `the local changes were kept in the upload queue. First operation: ${describeOperation(batch[0])}`)}\n`);
             }
             throw error;
         }
+        if (result.status === 'rejected') {
+            // The backend applied nothing. Keep the transaction so the command reports the
+            // failure (`--durability uploaded` must not succeed) instead of dropping edits.
+            const error = createUploadError(`PowerSync rejected the upload (${result.code ?? 'REJECTED'}): ${result.message ?? 'no message'}`, { code: result.code ?? 'REJECTED', fatal: true });
+            process.stderr.write(`${sanitizeForTerminal(`warning: ${error.message}; ${batch.length} operation(s) were kept in the upload queue. ` +
+                `First operation: ${describeOperation(batch[0])}`)}\n`);
+            throw error;
+        }
+        await transaction.complete();
     };
 }

package/dist/skills/check.d.ts

@@ -4,3 +4,4 @@ export type SkillCheckIssue = {
 };
 export declare function checkSkillContent(skill: string, content: string, skillDir?: string, expectedVersion?: string): SkillCheckIssue[];
 export declare function checkSkillsDirectory(skillsDir: string): SkillCheckIssue[];
+export declare function checkSkillDirectory(skillDir: string, expectedVersion?: string): SkillCheckIssue[];