@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/commands/savedViews/repo.js

@@ -1,512 +1,393 @@
-import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
-import { generateId } from '../../utils/id.js';
-import { createDefaultSavedViewConfig, createDefaultSavedViewFilter, mapSavedViewRow, validateSavedViewConfig, validateSavedViewFilter, } from './model.js';
-import { compileSavedViewFilter, compileSavedViewOrder, listSavedViewFields, normalizeSavedViewDateValues, validateSavedViewSemantics, } from './semantics.js';
+import { countSavedViewScopedRows, fetchSavedViewScopedPage, resolveSavedViewQueryScope, } from '../../vendor/electron/domain/saved-views.js';
+import { parseSavedViewZettelBoxDetails, SAVED_VIEW_LAYOUTS, } from '../../vendor/electron/shared/index.js';
+import { fetchDomainReadModel, previewInRolledBackTransaction, runDomainCommand, toDinoxError, withReadTransaction, } from '../domain/run.js';
+import { listPropertyDefinitions, valueTypeForPropertyType } from './fields.js';
+import { createDefaultSavedViewConfig, createDefaultSavedViewFilter, inspectSavedViewRow, parseSavedViewConfig, } from './model.js';
+export { listSavedViewFields } from './fields.js';
+const ACTIVE_VIEW_TYPE_SQL = `view_type IN (${SAVED_VIEW_LAYOUTS.map((layout) => `'${layout}'`).join(', ')})`;
 const SAVED_VIEW_COLUMNS = `
-  id,
-  user_id,
-  name,
-  emoji,
-  filter_json,
-  view_type,
-  config_json,
-  template_id,
-  group_id,
-  sort_rank,
-  pinned_at,
-  created_at,
-  updated_at,
-  is_del
+  id, user_id, name, emoji, filter_json, view_type, config_json, template_id, group_id,
+  sort_rank, pinned_at, created_at, updated_at, is_del
 `;
-function savedViewError(code, message, details) {
-    return new DinoxError(message, { code, details, recoverable: false });
+function nowIso() {
+    return new Date().toISOString();
 }
-function normalizeRequiredText(value, label, maxLength = 200) {
-    if (typeof value !== 'string' || !value.trim()) {
-        throw new DinoxError(`${label} is required`, { code: 'USAGE_ERROR' });
-    }
-    const normalized = value.trim();
-    if (normalized.length > maxLength) {
-        throw new DinoxError(`${label} must be at most ${maxLength} characters`, { code: 'USAGE_ERROR' });
-    }
-    return normalized;
-}
-function normalizeNullableText(value, label, maxLength) {
-    if (value === undefined || value === null)
-        return value;
-    const normalized = value.trim();
-    if (normalized.length > maxLength) {
-        throw new DinoxError(`${label} must be at most ${maxLength} characters`, { code: 'USAGE_ERROR' });
-    }
-    return normalized;
-}
-function normalizeNullableId(value, label) {
-    if (value === undefined || value === null)
-        return value;
-    const normalized = value.trim();
-    if (!normalized || normalized.length > 200) {
-        throw new DinoxError(`${label} must contain 1-200 characters`, { code: 'USAGE_ERROR' });
-    }
-    return normalized;
-}
-function normalizeNullableTimestamp(value, label) {
-    if (value === undefined || value === null)
-        return value;
-    const normalized = value.trim();
-    if (!normalized || normalized.length > 64) {
-        throw new DinoxError(`${label} must contain 1-64 characters`, { code: 'USAGE_ERROR' });
-    }
-    return normalized;
+function notFound(id) {
+    return new DinoxError(`Saved view not found: ${id}`, { code: 'SAVED_VIEW_NOT_FOUND', details: { viewId: id } });
 }
-function normalizeSortRank(value) {
-    if (value === undefined || value === null)
-        return value;
-    if (!Number.isSafeInteger(value)) {
-        throw new DinoxError('Saved view sort rank must be an integer', { code: 'USAGE_ERROR' });
-    }
-    return value;
-}
-function normalizeLimit(value, defaultValue, maxValue) {
-    if (value === undefined)
-        return defaultValue;
-    if (!Number.isSafeInteger(value) || value <= 0 || value > maxValue) {
-        throw new DinoxError(`Limit must be an integer between 1 and ${maxValue}`, { code: 'USAGE_ERROR' });
-    }
-    return value;
-}
-function normalizeOffset(value) {
-    if (value === undefined)
-        return 0;
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new DinoxError('Offset must be a non-negative integer', { code: 'USAGE_ERROR' });
-    }
-    return value;
-}
-function errorSummary(error) {
+function catalogItem(row) {
+    const inspection = inspectSavedViewRow(row);
+    const view = inspection.view;
     return {
-        code: error instanceof DinoxError ? error.code : 'SAVED_VIEW_INVALID_ROW',
-        message: error instanceof Error ? error.message : String(error),
+        id: view.id,
+        name: view.name,
+        emoji: view.emoji,
+        layout: inspection.valid ? inspection.view.layout : row.view_type,
+        templateId: view.templateId,
+        groupId: view.groupId,
+        sortRank: view.sortRank,
+        pinnedAt: view.pinnedAt,
+        createdAt: view.createdAt,
+        updatedAt: view.updatedAt,
+        valid: inspection.valid,
+        ...(inspection.valid ? {} : { error: { code: inspection.error.code, message: inspection.error.message } }),
     };
 }
 export async function listSavedViews(db, input) {
-    const userId = normalizeRequiredText(input.userId, 'Saved view user id');
-    const limit = normalizeLimit(input.limit, 200, 5_000);
-    const rows = await db.getAll(`
-      SELECT ${SAVED_VIEW_COLUMNS}
-      FROM c_saved_view
-      WHERE user_id = ?
-        AND view_type = 'table'
-        AND (is_del IS NULL OR is_del = 0)
-      ORDER BY
-        CASE WHEN pinned_at IS NULL OR trim(pinned_at) = '' THEN 1 ELSE 0 END ASC,
-        pinned_at DESC,
-        COALESCE(sort_rank, 0) ASC,
-        COALESCE(updated_at, created_at, id) DESC,
-        id DESC
-      LIMIT ?
-    `, [userId, limit]);
-    const items = [];
-    for (const row of rows) {
-        const id = row.id?.trim();
-        if (!id)
-            continue;
-        const base = {
-            id,
-            name: row.name?.trim() || '',
-            emoji: row.emoji,
-            templateId: row.template_id,
-            groupId: row.group_id,
-            sortRank: row.sort_rank,
-            pinnedAt: row.pinned_at,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        };
-        try {
-            mapSavedViewRow(row);
-            items.push({ ...base, valid: true });
-        }
-        catch (error) {
-            items.push({ ...base, valid: false, error: errorSummary(error) });
-        }
-    }
-    return items;
+    const rows = await fetchDomainReadModel(db, 'savedViews.catalog', {
+        userId: input.userId,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+    });
+    return rows.filter((row) => row.id?.trim()).map(catalogItem);
 }
 async function findSavedViewRow(db, input) {
-    const id = normalizeRequiredText(input.id, 'Saved view id');
-    const userId = normalizeRequiredText(input.userId, 'Saved view user id');
-    return db.getOptional(`
+    return (await db.getOptional(`
       SELECT ${SAVED_VIEW_COLUMNS}
       FROM c_saved_view
       WHERE id = ?
         AND user_id = ?
-        AND view_type = 'table'
+        AND ${ACTIVE_VIEW_TYPE_SQL}
         AND (is_del IS NULL OR is_del = 0)
       LIMIT 1
-    `, [id, userId]);
+    `, [input.id.trim(), input.userId])) ?? null;
 }
+/** Reads one view without throwing on stored rows the CLI cannot parse (see `valid`). */
 export async function getSavedView(db, input) {
     const row = await findSavedViewRow(db, input);
-    if (!row) {
-        throw savedViewError('SAVED_VIEW_NOT_FOUND', `Saved view not found: ${input.id}`, { viewId: input.id });
-    }
-    return mapSavedViewRow(row);
-}
-export async function resolveSavedViewQueryScope(db, input) {
-    const definition = await getSavedView(db, { id: input.viewId, userId: input.userId });
-    const semantics = await validateSavedViewSemantics(db, definition.userId, definition.filter, definition.config);
-    return {
-        definition,
-        semantics,
-        where: compileSavedViewFilter(definition.filter, semantics),
-        order: compileSavedViewOrder(definition.config, semantics),
-    };
+    if (!row)
+        throw notFound(input.id);
+    return inspectSavedViewRow(row);
 }
-async function fetchSavedViewPageRows(db, input, scope) {
-    return db.getAll(`
-      SELECT
-        n.id,
-        n.title,
-        n.created_at,
-        n.updated_at,
-        n.tags,
-        n.zettel_boxes,
-        n.source,
-        n.type,
-        n.starred_at,
-        n.properties
-      FROM c_note AS n
-      WHERE n.user_no = ?
-        AND (n.is_del IS NULL OR n.is_del = 0)
-        AND (${scope.where.sql})
-      ORDER BY ${scope.order.sql}
-      LIMIT ? OFFSET ?
-    `, [
-        scope.definition.userId,
-        ...scope.where.params,
-        ...scope.order.params,
-        input.limit,
-        input.offset,
-    ]);
-}
-export async function countSavedViewRows(db, input, scope) {
-    const resolvedScope = scope ?? await resolveSavedViewQueryScope(db, input);
-    const row = await db.getOptional(`
-      SELECT COUNT(*) AS total_count
-      FROM c_note AS n
-      WHERE n.user_no = ?
-        AND (n.is_del IS NULL OR n.is_del = 0)
-        AND (${resolvedScope.where.sql})
-    `, [resolvedScope.definition.userId, ...resolvedScope.where.params]);
-    const total = Number(row?.total_count ?? 0);
-    return Number.isFinite(total) ? Math.max(0, Math.trunc(total)) : 0;
-}
-function parseJsonObject(raw) {
+function parseJsonValue(raw) {
     if (!raw?.trim())
-        return {};
+        return undefined;
     try {
-        const value = JSON.parse(raw);
-        return value && typeof value === 'object' && !Array.isArray(value)
-            ? value
-            : {};
+        return JSON.parse(raw);
     }
     catch {
-        return {};
+        return undefined;
     }
 }
+function parseObject(raw) {
+    const value = parseJsonValue(raw);
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
 function parseStringArray(raw) {
-    if (!raw?.trim())
-        return [];
-    try {
-        const value = JSON.parse(raw);
-        return Array.isArray(value)
-            ? value.flatMap((item) => typeof item === 'string' && item.trim() ? [item.trim()] : [])
-            : [];
-    }
-    catch {
-        return [];
-    }
+    const value = parseJsonValue(raw);
+    return Array.isArray(value)
+        ? value.flatMap((item) => (typeof item === 'string' && item.trim() ? [item.trim()] : []))
+        : [];
 }
-function resolveFieldValue(row, properties, field) {
-    if (field.startsWith('prop.')) {
-        const key = field.slice('prop.'.length);
-        return Object.hasOwn(properties, key) ? properties[key] : undefined;
-    }
+function parseImages(raw) {
+    const value = parseJsonValue(raw);
+    return Array.isArray(value) ? value : [];
+}
+function resolveSystemValue(row, field) {
     switch (field) {
         case 'sys.title': return row.title;
         case 'sys.created_at': return row.created_at;
         case 'sys.updated_at': return row.updated_at;
-        case 'sys.tags': return parseStringArray(row.tags);
-        case 'sys.zettel_boxes': return parseStringArray(row.zettel_boxes);
+        case 'sys.starred_at': return row.starred_at;
         case 'sys.source': return row.source;
         case 'sys.type': return row.type;
-        case 'sys.starred_at': return row.starred_at;
+        case 'sys.tags': return parseStringArray(row.tags);
+        case 'sys.zettel_boxes': return parseStringArray(row.zettel_boxes);
+        case 'sys.images': return parseImages(row.images);
+        case 'sys.cover': return parseImages(row.images)[0] ?? null;
+        case 'sys.primary_resource_type': return row.primary_resource_type ?? null;
+        case 'sys.audio':
+        case 'sys.video':
+        case 'sys.file':
+            return row.primary_resource_type === field.slice('sys.'.length);
+        default: return undefined;
     }
 }
 function describeOption(value, options) {
     const option = options.find((candidate) => candidate.id === value);
     return option
-        ? { id: option.id, label: option.label, archived: option.archived, color: option.color }
+        ? { id: option.id, label: option.label, archived: option.archived, color: option.color, ...(option.group ? { group: option.group } : {}) }
         : { id: value, label: null, unknown: true };
 }
-function displayFieldValue(value, semantic) {
-    if (!semantic?.options)
+function displayValue(value, semantic) {
+    const options = semantic?.options;
+    if (!options)
         return value;
-    if (semantic.propertyType === 'select' && typeof value === 'string') {
-        return describeOption(value, semantic.options);
+    if ((semantic.propertyType === 'select' || semantic.propertyType === 'status') && typeof value === 'string') {
+        return describeOption(value, options);
     }
     if (semantic.propertyType === 'multi_select' && Array.isArray(value)) {
-        return value.map((item) => typeof item === 'string' ? describeOption(item, semantic.options) : item);
+        return value.map((item) => (typeof item === 'string' ? describeOption(item, options) : item));
     }
     return value;
 }
-function projectSavedViewRow(row, scope) {
-    const properties = parseJsonObject(row.properties);
+/** Row-level evaluation, aligned with desktop: non-finite side or division by zero → null. */
+export function evaluateComputedColumn(properties, column) {
+    const read = (field) => {
+        if (!field.startsWith('prop.'))
+            return null;
+        const raw = properties[field.slice('prop.'.length)];
+        return typeof raw === 'number' && Number.isFinite(raw) ? raw : null;
+    };
+    const left = read(column.expr.left);
+    const right = read(column.expr.right);
+    if (left === null || right === null)
+        return null;
+    switch (column.expr.op) {
+        case '*': return left * right;
+        case '/': return right === 0 ? null : left / right;
+        case '+': return left + right;
+        case '-': return left - right;
+    }
+}
+function projectRow(row, fields, computedColumns, semantics) {
+    const properties = parseObject(row.properties);
     const values = {};
     const displayValues = {};
-    let hasDisplayValues = false;
-    for (const column of scope.definition.config.columns) {
-        const value = resolveFieldValue(row, properties, column.field);
+    for (const field of fields) {
+        const value = field.startsWith('prop.')
+            ? (Object.hasOwn(properties, field.slice('prop.'.length)) ? properties[field.slice('prop.'.length)] : undefined)
+            : resolveSystemValue(row, field);
         if (value === undefined)
             continue;
-        values[column.field] = value;
-        const displayValue = displayFieldValue(value, scope.semantics.get(column.field));
-        if (displayValue !== value) {
-            displayValues[column.field] = displayValue;
-            hasDisplayValues = true;
+        values[field] = value;
+        if (field === 'sys.zettel_boxes') {
+            const details = parseSavedViewZettelBoxDetails(row.zettel_box_details);
+            if (details.length > 0)
+                displayValues[field] = details;
+            continue;
         }
+        const display = displayValue(value, semantics.get(field));
+        if (display !== value)
+            displayValues[field] = display;
+    }
+    for (const column of computedColumns) {
+        values[`calc.${column.id}`] = evaluateComputedColumn(properties, column);
     }
     return {
         id: row.id,
         title: row.title,
         values,
-        ...(hasDisplayValues ? { displayValues } : {}),
+        ...(Object.keys(displayValues).length > 0 ? { displayValues } : {}),
     };
 }
-export async function querySavedView(db, input) {
-    const limit = normalizeLimit(input.limit, 100, 500);
-    const offset = normalizeOffset(input.offset);
-    const scope = await resolveSavedViewQueryScope(db, input);
-    const [rawRows, totalCount] = await Promise.all([
-        fetchSavedViewPageRows(db, { userId: input.userId, limit, offset }, scope),
-        countSavedViewRows(db, input, scope),
-    ]);
-    const rows = rawRows.map((row) => projectSavedViewRow(row, scope));
-    const nextOffset = offset + rows.length;
-    const hasMore = nextOffset < totalCount;
-    return {
-        view: scope.definition,
-        columns: scope.definition.config.columns.map((column) => {
-            const semantic = scope.semantics.get(column.field);
+function projectedColumns(config, semantics) {
+    return [
+        ...config.columns.map((column) => {
+            const semantic = semantics.get(column.field);
             return {
                 field: column.field,
-                type: semantic.type,
-                propertyType: semantic.propertyType ?? null,
-                dateMode: semantic.dateMode ?? null,
-                ...(semantic.options ? { options: semantic.options } : {}),
+                type: semantic?.type ?? 'text',
+                propertyType: semantic?.propertyType ?? null,
+                dateMode: semantic?.dateMode ?? null,
+                ...(semantic?.displayOnly ? { displayOnly: true } : {}),
+                ...(semantic?.options ? { options: semantic.options } : {}),
             };
         }),
-        totalCount,
-        offset,
-        limit,
-        nextOffset: hasMore ? nextOffset : null,
-        hasMore,
-        rows,
-    };
+        ...(config.computedColumns ?? []).map((column) => ({
+            field: `calc.${column.id}`,
+            type: 'number',
+            propertyType: null,
+            dateMode: null,
+            computed: column,
+        })),
+    ];
+}
+async function resolveScope(db, input) {
+    try {
+        return await resolveSavedViewQueryScope(db, input);
+    }
+    catch (error) {
+        // Keep the "view exists but cannot be queried" failure distinct from a missing view.
+        const mapped = toDinoxError(error, 'savedViews.query');
+        if (mapped.code === 'SAVED_VIEW_NOT_FOUND')
+            throw notFound(input.viewId);
+        throw mapped;
+    }
 }
-export async function getSavedViewFieldCatalog(db, userId) {
-    normalizeRequiredText(userId, 'Saved view user id');
-    return listSavedViewFields(db, userId);
+export async function querySavedView(db, input) {
+    const limit = Math.min(500, Math.max(1, Math.trunc(input.limit ?? 100)));
+    const offset = Math.max(0, Math.trunc(input.offset ?? 0));
+    return withReadTransaction(db, async (tx) => {
+        const scope = await resolveScope(tx, input);
+        const pageInput = { viewId: input.viewId, userId: input.userId, timeZone: input.timeZone, limit, offset };
+        const rawRows = await fetchSavedViewScopedPage(tx, pageInput, scope);
+        const totalCount = await countSavedViewScopedRows(tx, pageInput, scope);
+        const view = await getSavedView(tx, { id: input.viewId, userId: input.userId });
+        const fields = scope.config.columns.map((column) => column.field);
+        const rows = rawRows.map((row) => projectRow(row, fields, scope.config.computedColumns ?? [], scope.semantics));
+        const nextOffset = offset + rows.length;
+        const hasMore = nextOffset < totalCount;
+        return {
+            view: view.view,
+            columns: projectedColumns(scope.config, scope.semantics),
+            totalCount,
+            offset,
+            limit,
+            nextOffset: hasMore ? nextOffset : null,
+            hasMore,
+            rows,
+        };
+    });
+}
+export async function countSavedViewRows(db, input) {
+    return withReadTransaction(db, async (tx) => {
+        const scope = await resolveScope(tx, input);
+        return countSavedViewScopedRows(tx, input, scope);
+    });
 }
-function normalizeCreateInput(input) {
+export async function getSavedViewAnalytics(db, input) {
+    const view = await getSavedView(db, { id: input.viewId, userId: input.userId });
+    const [analytics] = await fetchDomainReadModel(db, 'savedViews.analytics', {
+        viewId: input.viewId,
+        userId: input.userId,
+        ...(input.timeZone ? { timeZone: input.timeZone } : {}),
+    });
+    const config = view.valid ? view.view.config : undefined;
     return {
-        userId: normalizeRequiredText(input.userId, 'Saved view user id'),
-        name: normalizeRequiredText(input.name, 'Saved view name', 120),
-        emoji: normalizeNullableText(input.emoji, 'Saved view emoji', 120),
-        filter: validateSavedViewFilter(input.filter ?? createDefaultSavedViewFilter()),
-        config: validateSavedViewConfig(input.config ?? createDefaultSavedViewConfig()),
-        templateId: normalizeNullableId(input.templateId, 'Saved view template id'),
-        groupId: normalizeNullableId(input.groupId, 'Saved view group id'),
-        sortRank: normalizeSortRank(input.sortRank),
-        pinnedAt: normalizeNullableTimestamp(input.pinnedAt, 'Saved view pinned timestamp'),
-        updatedAt: normalizeNullableTimestamp(input.updatedAt ?? new Date().toISOString(), 'Saved view updated timestamp'),
+        stats: analytics?.stats ?? [],
+        charts: analytics?.charts ?? [],
+        summary: analytics?.summary ?? [],
+        config: {
+            ...(config?.stats ? { stats: config.stats } : {}),
+            ...(config?.charts ? { charts: config.charts } : {}),
+            ...(config?.summary ? { summary: config.summary } : {}),
+            ...(config?.computedColumns ? { computedColumns: config.computedColumns } : {}),
+        },
     };
 }
-function normalizeUpdateInput(input) {
-    const normalized = {
-        id: normalizeRequiredText(input.id, 'Saved view id'),
-        userId: normalizeRequiredText(input.userId, 'Saved view user id'),
-        ...(input.name === undefined ? {} : { name: normalizeRequiredText(input.name, 'Saved view name', 120) }),
-        ...(input.emoji === undefined ? {} : { emoji: normalizeNullableText(input.emoji, 'Saved view emoji', 120) }),
-        ...(input.filter === undefined ? {} : { filter: validateSavedViewFilter(input.filter) }),
-        ...(input.config === undefined ? {} : { config: validateSavedViewConfig(input.config) }),
-        ...(input.templateId === undefined ? {} : { templateId: normalizeNullableId(input.templateId, 'Saved view template id') }),
-        ...(input.groupId === undefined ? {} : { groupId: normalizeNullableId(input.groupId, 'Saved view group id') }),
-        ...(input.sortRank === undefined ? {} : { sortRank: normalizeSortRank(input.sortRank) }),
-        ...(input.pinnedAt === undefined ? {} : { pinnedAt: normalizeNullableTimestamp(input.pinnedAt, 'Saved view pinned timestamp') }),
-        updatedAt: normalizeNullableTimestamp(input.updatedAt ?? new Date().toISOString(), 'Saved view updated timestamp'),
-    };
-    if (normalized.name === undefined
-        && normalized.emoji === undefined
-        && normalized.filter === undefined
-        && normalized.config === undefined
-        && normalized.templateId === undefined
-        && normalized.groupId === undefined
-        && normalized.sortRank === undefined
-        && normalized.pinnedAt === undefined) {
-        throw new DinoxError('At least one saved-view field must be updated', { code: 'USAGE_ERROR' });
-    }
-    return normalized;
+async function propertySemantics(db, userId) {
+    const definitions = await listPropertyDefinitions(db, userId);
+    return new Map(definitions.map((definition) => [
+        `prop.${definition.key}`,
+        {
+            type: valueTypeForPropertyType(definition.type),
+            propertyType: definition.type,
+            ...(definition.options ? { options: definition.options } : {}),
+        },
+    ]));
+}
+/** Saved views whose `noteDetail` rule matches the note, with `$self` bound to it. */
+export async function getNoteDetailSections(db, input) {
+    return withReadTransaction(db, async (tx) => {
+        const sections = await fetchDomainReadModel(tx, 'savedViews.noteDetail', {
+            noteId: input.noteId,
+            userId: input.userId,
+            ...(input.timeZone ? { timeZone: input.timeZone } : {}),
+            ...(input.limit === undefined ? {} : { limit: input.limit }),
+        });
+        if (sections.length === 0)
+            return [];
+        const semantics = await propertySemantics(tx, input.userId);
+        const result = [];
+        for (const section of sections) {
+            const view = await getSavedView(tx, { id: section.view_id, userId: input.userId });
+            const config = view.valid ? view.view.config : createDefaultSavedViewConfig();
+            const fields = config.columns.map((column) => column.field);
+            result.push({
+                viewId: section.view_id,
+                name: section.name,
+                emoji: section.emoji,
+                totalCount: section.total_count,
+                columns: projectedColumns(config, semantics),
+                rows: section.rows.map((row) => projectRow(row, fields, config.computedColumns ?? [], semantics)),
+            });
+        }
+        return result;
+    });
+}
+function withLayout(config, layout) {
+    return layout === undefined || layout === config.layout ? config : { ...config, layout };
+}
+async function resolveUpdateConfig(db, input) {
+    if (input.config !== undefined)
+        return withLayout(input.config, input.layout);
+    if (input.layout === undefined)
+        return undefined;
+    const row = await findSavedViewRow(db, input);
+    if (!row)
+        throw notFound(input.id);
+    return withLayout(parseSavedViewConfig(row.config_json), input.layout);
+}
+function definedEntries(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-function mutationChanges(input) {
-    return Object.fromEntries(Object.entries({
+async function runCreate(db, input) {
+    const config = withLayout(input.config ?? createDefaultSavedViewConfig(), input.layout);
+    const { result: id } = await runDomainCommand(db, 'savedViews.create', definedEntries({
+        userId: input.userId,
+        name: input.name,
+        emoji: input.emoji,
+        filter: input.filter ?? createDefaultSavedViewFilter(),
+        config,
+        templateId: input.templateId,
+        groupId: input.groupId,
+        sortRank: input.sortRank,
+        pinnedAt: input.pinnedAt,
+        updatedAt: nowIso(),
+    }));
+    return getSavedView(db, { id, userId: input.userId });
+}
+async function runUpdate(db, input) {
+    const config = await resolveUpdateConfig(db, input);
+    const { result: changed } = await runDomainCommand(db, 'savedViews.update', definedEntries({
+        id: input.id,
+        userId: input.userId,
         name: input.name,
         emoji: input.emoji,
         filter: input.filter,
-        config: input.config,
+        config,
         templateId: input.templateId,
         groupId: input.groupId,
         sortRank: input.sortRank,
         pinnedAt: input.pinnedAt,
-    }).filter(([, value]) => value !== undefined));
-}
-export async function inspectCreateSavedView(db, input) {
-    const normalized = normalizeCreateInput(input);
-    const semantics = await validateSavedViewSemantics(db, normalized.userId, normalized.filter, normalized.config);
-    const filter = normalizeSavedViewDateValues(normalized.filter, semantics);
-    return {
-        action: 'create',
-        target: null,
-        changes: mutationChanges({ ...normalized, filter }),
-    };
+        updatedAt: nowIso(),
+    }));
+    if (!changed)
+        throw notFound(input.id);
+    // Re-read leniently: a metadata-only update of a view this CLI cannot fully parse must
+    // still report success instead of failing after the write committed.
+    return getSavedView(db, input);
+}
+async function runDelete(db, input) {
+    const before = await getSavedView(db, input);
+    const { result: changed } = await runDomainCommand(db, 'savedViews.softDelete', {
+        id: input.id,
+        userId: input.userId,
+        updatedAt: nowIso(),
+    });
+    if (!changed)
+        throw notFound(input.id);
+    return before;
 }
 export async function createSavedView(db, input) {
-    const normalized = normalizeCreateInput(input);
-    const id = await withPowerSyncWriteTransaction(db, async (tx) => {
-        const semantics = await validateSavedViewSemantics(tx, normalized.userId, normalized.filter, normalized.config);
-        const filter = normalizeSavedViewDateValues(normalized.filter, semantics);
-        const nextRank = normalized.sortRank ?? Number((await tx.getOptional(`
-        SELECT COALESCE(MAX(sort_rank), -1) + 1 AS next_rank
-        FROM c_saved_view
-        WHERE user_id = ?
-          AND (is_del IS NULL OR is_del = 0)
-      `, [normalized.userId]))?.next_rank ?? 0);
-        const createdId = generateId();
-        await tx.execute(`
-        INSERT INTO c_saved_view (
-          id,
-          user_id,
-          name,
-          emoji,
-          filter_json,
-          view_type,
-          config_json,
-          template_id,
-          group_id,
-          sort_rank,
-          pinned_at,
-          created_at,
-          updated_at,
-          is_del
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
-      `, [
-            createdId,
-            normalized.userId,
-            normalized.name,
-            normalized.emoji ?? null,
-            JSON.stringify(filter),
-            normalized.config.layout,
-            JSON.stringify(normalized.config),
-            normalized.templateId ?? null,
-            normalized.groupId ?? null,
-            nextRank,
-            normalized.pinnedAt ?? null,
-            normalized.updatedAt,
-            normalized.updatedAt,
-        ]);
-        return createdId;
-    });
-    return getSavedView(db, { id, userId: normalized.userId });
-}
-export async function inspectUpdateSavedView(db, input) {
-    const normalized = normalizeUpdateInput(input);
-    const target = await getSavedView(db, normalized);
-    let filter = normalized.filter;
-    if (normalized.filter !== undefined || normalized.config !== undefined) {
-        const semantics = await validateSavedViewSemantics(db, normalized.userId, normalized.filter, normalized.config);
-        if (filter)
-            filter = normalizeSavedViewDateValues(filter, semantics);
-    }
-    return {
-        action: 'update',
-        target,
-        changes: mutationChanges({ ...normalized, ...(filter ? { filter } : {}) }),
-    };
+    return runCreate(db, input);
 }
 export async function updateSavedView(db, input) {
-    const normalized = normalizeUpdateInput(input);
-    await withPowerSyncWriteTransaction(db, async (tx) => {
-        const target = await findSavedViewRow(tx, normalized);
-        if (!target) {
-            throw savedViewError('SAVED_VIEW_NOT_FOUND', `Saved view not found: ${normalized.id}`, { viewId: normalized.id });
-        }
-        let filter = normalized.filter;
-        if (normalized.filter !== undefined || normalized.config !== undefined) {
-            const semantics = await validateSavedViewSemantics(tx, normalized.userId, normalized.filter, normalized.config);
-            if (filter)
-                filter = normalizeSavedViewDateValues(filter, semantics);
-        }
-        const assignments = [];
-        const params = [];
-        const set = (column, value) => {
-            assignments.push(`${column} = ?`);
-            params.push(value);
-        };
-        if (normalized.name !== undefined)
-            set('name', normalized.name);
-        if (normalized.emoji !== undefined)
-            set('emoji', normalized.emoji);
-        if (filter !== undefined)
-            set('filter_json', JSON.stringify(filter));
-        if (normalized.config !== undefined) {
-            set('config_json', JSON.stringify(normalized.config));
-            set('view_type', normalized.config.layout);
-        }
-        if (normalized.templateId !== undefined)
-            set('template_id', normalized.templateId);
-        if (normalized.groupId !== undefined)
-            set('group_id', normalized.groupId);
-        if (normalized.sortRank !== undefined)
-            set('sort_rank', normalized.sortRank);
-        if (normalized.pinnedAt !== undefined)
-            set('pinned_at', normalized.pinnedAt);
-        set('updated_at', normalized.updatedAt);
-        set('is_del', 0);
-        await tx.execute(`UPDATE c_saved_view SET ${assignments.join(', ')} WHERE id = ? AND user_id = ?`, [...params, normalized.id, normalized.userId]);
-    });
-    return getSavedView(db, normalized);
-}
-export async function inspectDeleteSavedView(db, input) {
-    const target = await getSavedView(db, input);
-    return {
-        action: 'delete',
-        target,
-        changes: { isDel: 1 },
-    };
+    return runUpdate(db, input);
 }
 export async function deleteSavedView(db, input) {
-    const id = normalizeRequiredText(input.id, 'Saved view id');
-    const userId = normalizeRequiredText(input.userId, 'Saved view user id');
-    const updatedAt = normalizeNullableTimestamp(input.updatedAt ?? new Date().toISOString(), 'Saved view updated timestamp');
-    return withPowerSyncWriteTransaction(db, async (tx) => {
-        const target = await getSavedView(tx, { id, userId });
-        await tx.execute(`
-        UPDATE c_saved_view
-        SET is_del = 1,
-          updated_at = ?
-        WHERE id = ?
-          AND user_id = ?
-      `, [updatedAt, id, userId]);
-        return target;
-    });
+    return runDelete(db, input);
+}
+export async function previewCreateSavedView(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runCreate(tx, input), async (_tx, after) => ({
+        action: 'create',
+        before: null,
+        after,
+    }));
+}
+export async function previewUpdateSavedView(db, input) {
+    const before = await getSavedView(db, input);
+    return previewInRolledBackTransaction(db, (tx) => runUpdate(tx, input), async (_tx, after) => ({
+        action: 'update',
+        before,
+        after,
+    }));
+}
+export async function previewDeleteSavedView(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runDelete(tx, input), async (_tx, before) => ({
+        action: 'delete',
+        before,
+        after: null,
+    }));
 }