@dinoxx/dinox-cli 1.1.0 → 2.0.0

package/dist/commands/savedViews/repo.js

@@ -0,0 +1,512 @@
+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';
+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
+`;
+function savedViewError(code, message, details) {
+    return new DinoxError(message, { code, details, recoverable: false });
+}
+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 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) {
+    return {
+        code: error instanceof DinoxError ? error.code : 'SAVED_VIEW_INVALID_ROW',
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+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;
+}
+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(`
+      SELECT ${SAVED_VIEW_COLUMNS}
+      FROM c_saved_view
+      WHERE id = ?
+        AND user_id = ?
+        AND view_type = 'table'
+        AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [id, userId]);
+}
+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),
+    };
+}
+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) {
+    if (!raw?.trim())
+        return {};
+    try {
+        const value = JSON.parse(raw);
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+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 [];
+    }
+}
+function resolveFieldValue(row, properties, field) {
+    if (field.startsWith('prop.')) {
+        const key = field.slice('prop.'.length);
+        return Object.hasOwn(properties, key) ? properties[key] : undefined;
+    }
+    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.source': return row.source;
+        case 'sys.type': return row.type;
+        case 'sys.starred_at': return row.starred_at;
+    }
+}
+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: value, label: null, unknown: true };
+}
+function displayFieldValue(value, semantic) {
+    if (!semantic?.options)
+        return value;
+    if (semantic.propertyType === 'select' && typeof value === 'string') {
+        return describeOption(value, semantic.options);
+    }
+    if (semantic.propertyType === 'multi_select' && Array.isArray(value)) {
+        return value.map((item) => typeof item === 'string' ? describeOption(item, semantic.options) : item);
+    }
+    return value;
+}
+function projectSavedViewRow(row, scope) {
+    const properties = parseJsonObject(row.properties);
+    const values = {};
+    const displayValues = {};
+    let hasDisplayValues = false;
+    for (const column of scope.definition.config.columns) {
+        const value = resolveFieldValue(row, properties, column.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;
+        }
+    }
+    return {
+        id: row.id,
+        title: row.title,
+        values,
+        ...(hasDisplayValues ? { 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);
+            return {
+                field: column.field,
+                type: semantic.type,
+                propertyType: semantic.propertyType ?? null,
+                dateMode: semantic.dateMode ?? null,
+                ...(semantic.options ? { options: semantic.options } : {}),
+            };
+        }),
+        totalCount,
+        offset,
+        limit,
+        nextOffset: hasMore ? nextOffset : null,
+        hasMore,
+        rows,
+    };
+}
+export async function getSavedViewFieldCatalog(db, userId) {
+    normalizeRequiredText(userId, 'Saved view user id');
+    return listSavedViewFields(db, userId);
+}
+function normalizeCreateInput(input) {
+    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'),
+    };
+}
+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;
+}
+function mutationChanges(input) {
+    return Object.fromEntries(Object.entries({
+        name: input.name,
+        emoji: input.emoji,
+        filter: input.filter,
+        config: input.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 }),
+    };
+}
+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 } : {}) }),
+    };
+}
+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 },
+    };
+}
+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;
+    });
+}

package/dist/commands/savedViews/semantics.d.ts

@@ -0,0 +1,46 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type SavedViewConfig, type SavedViewFieldRef, type SavedViewFilter } from './model.js';
+export type PropertyType = 'text' | 'number' | 'date' | 'select' | 'multi_select' | 'url' | 'checkbox' | 'relation';
+export type PropertyOption = {
+    id: string;
+    label: string;
+    color: string;
+    sortRank: number;
+    archived: boolean;
+};
+export type SavedViewSemanticType = 'text' | 'select' | 'list' | 'number' | 'date' | 'boolean';
+export type SavedViewFieldSemantic = {
+    type: SavedViewSemanticType;
+    propertyType?: PropertyType;
+    dateMode?: 'date' | 'datetime';
+    options?: readonly PropertyOption[];
+};
+export type SavedViewSqlFragment = {
+    sql: string;
+    params: unknown[];
+};
+export type SavedViewFieldCatalogItem = {
+    field: SavedViewFieldRef;
+    name: string;
+    type: SavedViewSemanticType;
+    propertyType: PropertyType;
+    sortable: boolean;
+    filterOperators: string[];
+    available: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+    options?: readonly PropertyOption[];
+    propertyDefinitionId?: string;
+    description?: string | null;
+    icon?: string | null;
+};
+export declare const SYSTEM_FIELD_SEMANTICS: Readonly<Record<string, SavedViewFieldSemantic>>;
+export declare function validateSavedViewSemantics(db: AbstractPowerSyncDatabase, userId: string, filter?: SavedViewFilter, config?: SavedViewConfig): Promise<Map<SavedViewFieldRef, SavedViewFieldSemantic>>;
+export declare function normalizeDatePropertyValue(value: unknown, mode: 'date' | 'datetime'): string | null;
+export declare function normalizeSavedViewDateValues(filter: SavedViewFilter, semantics: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>): SavedViewFilter;
+export declare function compileSavedViewField(field: SavedViewFieldRef): SavedViewSqlFragment;
+export declare function compileSavedViewFilter(filter: SavedViewFilter, semantics?: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>): SavedViewSqlFragment;
+export declare function compileSavedViewOrder(config: SavedViewConfig, semantics?: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>): SavedViewSqlFragment;
+export declare function listSavedViewFields(db: AbstractPowerSyncDatabase, userId: string): Promise<SavedViewFieldCatalogItem[]>;