@dinoxx/dinox-cli 1.1.0 → 2.0.0

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

@@ -0,0 +1,87 @@
+export declare const SAVED_VIEW_FILTER_VERSION = 1;
+export declare const SAVED_VIEW_CONFIG_VERSION = 1;
+export declare const MAX_SAVED_VIEW_FILTER_DEPTH = 8;
+export declare const MAX_SAVED_VIEW_FILTER_NODES = 100;
+export declare const MAX_SAVED_VIEW_FILTER_VALUE_LENGTH = 2000;
+export declare const MAX_SAVED_VIEW_COLUMNS = 100;
+export declare const MAX_SAVED_VIEW_SORTS = 20;
+export declare const SAVED_VIEW_SYSTEM_FIELDS: readonly ["title", "created_at", "updated_at", "tags", "zettel_boxes", "source", "type", "starred_at"];
+export declare const SAVED_VIEW_FILTER_OPERATORS: readonly ["equals", "notEquals", "contains", "notContains", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "isEmpty", "isNotEmpty"];
+export type SavedViewSystemField = (typeof SAVED_VIEW_SYSTEM_FIELDS)[number];
+export type SavedViewFieldRef = `sys.${SavedViewSystemField}` | `prop.${string}`;
+export type SavedViewFilterOperator = (typeof SAVED_VIEW_FILTER_OPERATORS)[number];
+export type SavedViewFilterValue = string | number | boolean | null;
+export type SavedViewFilterCondition = {
+    kind: 'condition';
+    field: SavedViewFieldRef;
+    operator: SavedViewFilterOperator;
+    value?: SavedViewFilterValue;
+};
+export type SavedViewFilterGroup = {
+    kind: 'group';
+    operator: 'and' | 'or';
+    children: SavedViewFilterNode[];
+};
+export type SavedViewFilterNot = {
+    kind: 'not';
+    child: SavedViewFilterNode;
+};
+export type SavedViewFilterNode = SavedViewFilterCondition | SavedViewFilterGroup | SavedViewFilterNot;
+export type SavedViewFilter = {
+    version: typeof SAVED_VIEW_FILTER_VERSION;
+    root: SavedViewFilterNode | null;
+};
+export type SavedViewColumn = {
+    field: SavedViewFieldRef;
+};
+export type SavedViewSort = {
+    field: SavedViewFieldRef;
+    direction: 'asc' | 'desc';
+};
+export type SavedViewConfig = {
+    version: typeof SAVED_VIEW_CONFIG_VERSION;
+    layout: 'table';
+    columns: SavedViewColumn[];
+    sort?: SavedViewSort[];
+};
+export type SavedViewRow = {
+    id: string;
+    user_id: string | null;
+    name: string | null;
+    emoji: string | null;
+    filter_json: string | null;
+    view_type: string | null;
+    config_json: string | null;
+    template_id: string | null;
+    group_id: string | null;
+    sort_rank: number | null;
+    pinned_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+};
+export type SavedViewDefinition = {
+    id: string;
+    userId: string;
+    name: string;
+    emoji: string | null;
+    filter: SavedViewFilter;
+    config: SavedViewConfig;
+    templateId: string | null;
+    groupId: string | null;
+    sortRank: number | null;
+    pinnedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+export declare function isNotePropertyKeyValid(value: unknown): value is string;
+export declare function isSavedViewFieldRef(value: unknown): value is SavedViewFieldRef;
+export declare function validateSavedViewFilter(value: unknown): SavedViewFilter;
+export declare function parseSavedViewFilter(raw: string | null | undefined): SavedViewFilter;
+export declare function serializeSavedViewFilter(value: unknown): string;
+export declare function validateSavedViewConfig(value: unknown): SavedViewConfig;
+export declare function parseSavedViewConfig(raw: string | null | undefined): SavedViewConfig;
+export declare function serializeSavedViewConfig(value: unknown): string;
+export declare function createDefaultSavedViewFilter(): SavedViewFilter;
+export declare function createDefaultSavedViewConfig(): SavedViewConfig;
+export declare function mapSavedViewRow(row: SavedViewRow): SavedViewDefinition;

package/dist/commands/savedViews/model.js

@@ -0,0 +1,306 @@
+import { DinoxError } from '../../utils/errors.js';
+export const SAVED_VIEW_FILTER_VERSION = 1;
+export const SAVED_VIEW_CONFIG_VERSION = 1;
+export const MAX_SAVED_VIEW_FILTER_DEPTH = 8;
+export const MAX_SAVED_VIEW_FILTER_NODES = 100;
+export const MAX_SAVED_VIEW_FILTER_VALUE_LENGTH = 2_000;
+export const MAX_SAVED_VIEW_COLUMNS = 100;
+export const MAX_SAVED_VIEW_SORTS = 20;
+export const SAVED_VIEW_SYSTEM_FIELDS = [
+    'title',
+    'created_at',
+    'updated_at',
+    'tags',
+    'zettel_boxes',
+    'source',
+    'type',
+    'starred_at',
+];
+export const SAVED_VIEW_FILTER_OPERATORS = [
+    'equals',
+    'notEquals',
+    'contains',
+    'notContains',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'isEmpty',
+    'isNotEmpty',
+];
+const systemFieldRefs = new Set(SAVED_VIEW_SYSTEM_FIELDS.map((field) => `sys.${field}`));
+const filterOperators = new Set(SAVED_VIEW_FILTER_OPERATORS);
+const valueRequiredOperators = new Set([
+    'contains',
+    'notContains',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+]);
+const valuelessOperators = new Set(['isEmpty', 'isNotEmpty']);
+function formatError(message, code, details) {
+    return new DinoxError(message, {
+        code,
+        details,
+        recoverable: false,
+    });
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function assertAllowedKeys(record, allowed, label, code) {
+    const allowedKeys = new Set(allowed);
+    const unknownKeys = Object.keys(record).filter((key) => !allowedKeys.has(key));
+    if (unknownKeys.length > 0) {
+        throw formatError(`${label} contains unsupported fields`, code, { unknownKeys });
+    }
+}
+function parseStoredJson(raw, label, code) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        throw formatError(`${label} is required`, code);
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (cause) {
+        throw formatError(`${label} must be valid JSON`, code, {
+            cause: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+}
+export function isNotePropertyKeyValid(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed !== value || trimmed.length > 64)
+        return false;
+    if (trimmed === '__proto__')
+        return false;
+    return !trimmed.includes('.') && !/[\n\r\t]/.test(trimmed);
+}
+export function isSavedViewFieldRef(value) {
+    if (typeof value !== 'string')
+        return false;
+    if (systemFieldRefs.has(value))
+        return true;
+    return value.startsWith('prop.') && isNotePropertyKeyValid(value.slice('prop.'.length));
+}
+function validateFilterValue(value, code) {
+    if (value === null || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.length <= MAX_SAVED_VIEW_FILTER_VALUE_LENGTH)
+        return value;
+    throw formatError('Saved view filter contains an invalid value', code, {
+        maxStringLength: MAX_SAVED_VIEW_FILTER_VALUE_LENGTH,
+    });
+}
+function validateFilterNode(value, state, depth) {
+    const code = 'SAVED_VIEW_INVALID_FILTER';
+    if (depth > MAX_SAVED_VIEW_FILTER_DEPTH) {
+        throw formatError(`Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_DEPTH} levels`, code);
+    }
+    if (!isPlainRecord(value)) {
+        throw formatError('Saved view filter nodes must be objects', code);
+    }
+    state.count += 1;
+    if (state.count > MAX_SAVED_VIEW_FILTER_NODES) {
+        throw formatError(`Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_NODES} nodes`, code);
+    }
+    if (value.kind === 'condition') {
+        assertAllowedKeys(value, ['kind', 'field', 'operator', 'value'], 'Saved view filter condition', code);
+        if (!isSavedViewFieldRef(value.field)) {
+            throw formatError('Saved view filter contains an invalid field reference', code, { field: value.field });
+        }
+        if (typeof value.operator !== 'string' || !filterOperators.has(value.operator)) {
+            throw formatError('Saved view filter contains an invalid operator', code, { operator: value.operator });
+        }
+        const operator = value.operator;
+        const hasValue = Object.hasOwn(value, 'value');
+        const parsedValue = hasValue ? validateFilterValue(value.value, code) : undefined;
+        if (valueRequiredOperators.has(operator)
+            && (parsedValue === undefined || parsedValue === null || (typeof parsedValue === 'string' && !parsedValue.trim()))) {
+            throw formatError(`Saved view operator ${operator} requires a non-empty value`, code);
+        }
+        if (valuelessOperators.has(operator) && parsedValue !== undefined && parsedValue !== null) {
+            throw formatError(`Saved view operator ${operator} does not accept a value`, code);
+        }
+        return {
+            kind: 'condition',
+            field: value.field,
+            operator,
+            ...(hasValue ? { value: parsedValue } : {}),
+        };
+    }
+    if (value.kind === 'group') {
+        assertAllowedKeys(value, ['kind', 'operator', 'children'], 'Saved view filter group', code);
+        if (value.operator !== 'and' && value.operator !== 'or') {
+            throw formatError('Saved view filter group operator must be and or or', code);
+        }
+        if (!Array.isArray(value.children) || value.children.length > MAX_SAVED_VIEW_FILTER_NODES) {
+            throw formatError(`Saved view filter groups support at most ${MAX_SAVED_VIEW_FILTER_NODES} children`, code);
+        }
+        return {
+            kind: 'group',
+            operator: value.operator,
+            children: value.children.map((child) => validateFilterNode(child, state, depth + 1)),
+        };
+    }
+    if (value.kind === 'not') {
+        assertAllowedKeys(value, ['kind', 'child'], 'Saved view filter not node', code);
+        return {
+            kind: 'not',
+            child: validateFilterNode(value.child, state, depth + 1),
+        };
+    }
+    throw formatError('Saved view filter contains an unsupported node kind', code, { kind: value.kind });
+}
+export function validateSavedViewFilter(value) {
+    const code = 'SAVED_VIEW_INVALID_FILTER';
+    if (!isPlainRecord(value)) {
+        throw formatError('Saved view filter must be a versioned object', code);
+    }
+    if (value.version !== SAVED_VIEW_FILTER_VERSION) {
+        throw formatError(`Unsupported saved view filter version: ${String(value.version)}`, 'SAVED_VIEW_UNSUPPORTED_FILTER_VERSION', {
+            supportedVersion: SAVED_VIEW_FILTER_VERSION,
+            receivedVersion: value.version,
+        });
+    }
+    assertAllowedKeys(value, ['version', 'root'], 'Saved view filter', code);
+    if (!Object.hasOwn(value, 'root')) {
+        throw formatError('Saved view filter root is required', code);
+    }
+    return {
+        version: SAVED_VIEW_FILTER_VERSION,
+        root: value.root === null ? null : validateFilterNode(value.root, { count: 0 }, 1),
+    };
+}
+export function parseSavedViewFilter(raw) {
+    return validateSavedViewFilter(parseStoredJson(raw, 'Saved view filter_json', 'SAVED_VIEW_INVALID_FILTER'));
+}
+export function serializeSavedViewFilter(value) {
+    return JSON.stringify(validateSavedViewFilter(value));
+}
+export function validateSavedViewConfig(value) {
+    const code = 'SAVED_VIEW_INVALID_CONFIG';
+    if (!isPlainRecord(value)) {
+        throw formatError('Saved view config must be a versioned object', code);
+    }
+    if (value.version !== SAVED_VIEW_CONFIG_VERSION) {
+        throw formatError(`Unsupported saved view config version: ${String(value.version)}`, 'SAVED_VIEW_UNSUPPORTED_CONFIG_VERSION', {
+            supportedVersion: SAVED_VIEW_CONFIG_VERSION,
+            receivedVersion: value.version,
+        });
+    }
+    assertAllowedKeys(value, ['version', 'layout', 'columns', 'sort'], 'Saved view config', code);
+    if (value.layout !== 'table') {
+        throw formatError(`Unsupported saved view layout: ${String(value.layout)}`, 'SAVED_VIEW_UNSUPPORTED_LAYOUT', {
+            supportedLayouts: ['table'],
+        });
+    }
+    if (!Array.isArray(value.columns) || value.columns.length === 0 || value.columns.length > MAX_SAVED_VIEW_COLUMNS) {
+        throw formatError(`Saved view config requires 1-${MAX_SAVED_VIEW_COLUMNS} columns`, code);
+    }
+    const columnFields = new Set();
+    const columns = value.columns.map((column, index) => {
+        if (!isPlainRecord(column)) {
+            throw formatError('Saved view columns must be objects', code, { index });
+        }
+        assertAllowedKeys(column, ['field'], 'Saved view column', code);
+        if (!isSavedViewFieldRef(column.field)) {
+            throw formatError('Saved view config contains an invalid column field', code, { index, field: column.field });
+        }
+        if (columnFields.has(column.field)) {
+            throw formatError('Saved view columns must be unique', code, { index, field: column.field });
+        }
+        columnFields.add(column.field);
+        return { field: column.field };
+    });
+    if (columns[0]?.field !== 'sys.title') {
+        throw formatError('The title field must be the first saved view column', code);
+    }
+    let sort;
+    if (value.sort !== undefined) {
+        if (!Array.isArray(value.sort) || value.sort.length > MAX_SAVED_VIEW_SORTS) {
+            throw formatError(`Saved view config supports at most ${MAX_SAVED_VIEW_SORTS} sort fields`, code);
+        }
+        const sortFields = new Set();
+        sort = value.sort.map((item, index) => {
+            if (!isPlainRecord(item)) {
+                throw formatError('Saved view sort entries must be objects', code, { index });
+            }
+            assertAllowedKeys(item, ['field', 'direction'], 'Saved view sort', code);
+            if (!isSavedViewFieldRef(item.field)) {
+                throw formatError('Saved view config contains an invalid sort field', code, { index, field: item.field });
+            }
+            if (item.direction !== 'asc' && item.direction !== 'desc') {
+                throw formatError('Saved view sort direction must be asc or desc', code, { index });
+            }
+            if (sortFields.has(item.field)) {
+                throw formatError('Saved view sort fields must be unique', code, { index, field: item.field });
+            }
+            sortFields.add(item.field);
+            return { field: item.field, direction: item.direction };
+        });
+    }
+    return {
+        version: SAVED_VIEW_CONFIG_VERSION,
+        layout: 'table',
+        columns,
+        ...(sort === undefined ? {} : { sort }),
+    };
+}
+export function parseSavedViewConfig(raw) {
+    return validateSavedViewConfig(parseStoredJson(raw, 'Saved view config_json', 'SAVED_VIEW_INVALID_CONFIG'));
+}
+export function serializeSavedViewConfig(value) {
+    return JSON.stringify(validateSavedViewConfig(value));
+}
+export function createDefaultSavedViewFilter() {
+    return { version: SAVED_VIEW_FILTER_VERSION, root: null };
+}
+export function createDefaultSavedViewConfig() {
+    return {
+        version: SAVED_VIEW_CONFIG_VERSION,
+        layout: 'table',
+        columns: [{ field: 'sys.title' }, { field: 'sys.updated_at' }],
+        sort: [{ field: 'sys.updated_at', direction: 'desc' }],
+    };
+}
+export function mapSavedViewRow(row) {
+    const id = row.id.trim();
+    const userId = row.user_id?.trim() ?? '';
+    const name = row.name?.trim() ?? '';
+    if (!id || !userId || !name || name.length > 120) {
+        throw formatError('c_saved_view row is missing a valid id, user_id, or name', 'SAVED_VIEW_INVALID_ROW', {
+            id: row.id,
+            userId: row.user_id,
+            name: row.name,
+        });
+    }
+    if (row.view_type !== 'table') {
+        throw formatError(`Unsupported c_saved_view view_type: ${String(row.view_type)}`, 'SAVED_VIEW_UNSUPPORTED_LAYOUT');
+    }
+    const filter = parseSavedViewFilter(row.filter_json);
+    const config = parseSavedViewConfig(row.config_json);
+    if (config.layout !== row.view_type) {
+        throw formatError('c_saved_view view_type must match config_json.layout', 'SAVED_VIEW_INVALID_ROW');
+    }
+    return {
+        id,
+        userId,
+        name,
+        emoji: row.emoji,
+        filter,
+        config,
+        templateId: row.template_id,
+        groupId: row.group_id,
+        sortRank: row.sort_rank,
+        pinnedAt: row.pinned_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}

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

@@ -0,0 +1,123 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type SavedViewConfig, type SavedViewDefinition, type SavedViewFieldRef, type SavedViewFilter } from './model.js';
+import { type PropertyOption, type SavedViewFieldCatalogItem, type SavedViewFieldSemantic, type SavedViewSqlFragment } from './semantics.js';
+export type SavedViewCatalogItem = {
+    id: string;
+    name: string;
+    emoji: string | null;
+    templateId: string | null;
+    groupId: string | null;
+    sortRank: number | null;
+    pinnedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    valid: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+};
+export type SavedViewPageRow = {
+    id: string;
+    title: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    tags: string | null;
+    zettel_boxes: string | null;
+    source: string | null;
+    type: string | null;
+    starred_at: string | null;
+    properties: string | null;
+};
+export type SavedViewQueryScope = {
+    definition: SavedViewDefinition;
+    semantics: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>;
+    where: SavedViewSqlFragment;
+    order: SavedViewSqlFragment;
+};
+export type SavedViewProjectedRow = {
+    id: string;
+    title: string | null;
+    values: Partial<Record<SavedViewFieldRef, unknown>>;
+    displayValues?: Partial<Record<SavedViewFieldRef, unknown>>;
+};
+export type SavedViewQueryResult = {
+    view: SavedViewDefinition;
+    columns: Array<{
+        field: SavedViewFieldRef;
+        type: SavedViewFieldSemantic['type'];
+        propertyType: SavedViewFieldSemantic['propertyType'] | null;
+        dateMode: SavedViewFieldSemantic['dateMode'] | null;
+        options?: readonly PropertyOption[];
+    }>;
+    totalCount: number;
+    offset: number;
+    limit: number;
+    nextOffset: number | null;
+    hasMore: boolean;
+    rows: SavedViewProjectedRow[];
+};
+export type CreateSavedViewInput = {
+    userId: string;
+    name: string;
+    emoji?: string | null;
+    filter?: SavedViewFilter;
+    config?: SavedViewConfig;
+    templateId?: string | null;
+    groupId?: string | null;
+    sortRank?: number | null;
+    pinnedAt?: string | null;
+    updatedAt?: string;
+};
+export type UpdateSavedViewInput = {
+    id: string;
+    userId: string;
+    name?: string;
+    emoji?: string | null;
+    filter?: SavedViewFilter;
+    config?: SavedViewConfig;
+    templateId?: string | null;
+    groupId?: string | null;
+    sortRank?: number | null;
+    pinnedAt?: string | null;
+    updatedAt?: string;
+};
+export type DeleteSavedViewInput = {
+    id: string;
+    userId: string;
+    updatedAt?: string;
+};
+export type SavedViewMutationPlan = {
+    action: 'create' | 'update' | 'delete';
+    target: SavedViewDefinition | null;
+    changes: Record<string, unknown>;
+};
+export declare function listSavedViews(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    limit?: number;
+}): Promise<SavedViewCatalogItem[]>;
+export declare function getSavedView(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    userId: string;
+}): Promise<SavedViewDefinition>;
+export declare function resolveSavedViewQueryScope(db: AbstractPowerSyncDatabase, input: {
+    viewId: string;
+    userId: string;
+}): Promise<SavedViewQueryScope>;
+export declare function countSavedViewRows(db: AbstractPowerSyncDatabase, input: {
+    viewId: string;
+    userId: string;
+}, scope?: SavedViewQueryScope): Promise<number>;
+export declare function querySavedView(db: AbstractPowerSyncDatabase, input: {
+    viewId: string;
+    userId: string;
+    limit?: number;
+    offset?: number;
+}): Promise<SavedViewQueryResult>;
+export declare function getSavedViewFieldCatalog(db: AbstractPowerSyncDatabase, userId: string): Promise<SavedViewFieldCatalogItem[]>;
+export declare function inspectCreateSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewMutationPlan>;
+export declare function createSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewDefinition>;
+export declare function inspectUpdateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewMutationPlan>;
+export declare function updateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewDefinition>;
+export declare function inspectDeleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewMutationPlan>;
+export declare function deleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewDefinition>;