@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/commands/savedViews/semantics.js

@@ -0,0 +1,738 @@
+import { DinoxError } from '../../utils/errors.js';
+import { SAVED_VIEW_SYSTEM_FIELDS, } from './model.js';
+const PROPERTY_DEF_CONFIG_KEY_PREFIX = 'property_def.config.v1.';
+const PROPERTY_OPTION_COLORS = new Set([
+    'gray',
+    'red',
+    'orange',
+    'yellow',
+    'green',
+    'blue',
+    'purple',
+    'pink',
+]);
+const PROPERTY_TYPES = new Set([
+    'text',
+    'number',
+    'date',
+    'select',
+    'multi_select',
+    'url',
+    'checkbox',
+    'relation',
+]);
+const FALLBACK_ISO_4217_CODES = new Set('AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BRL BSD BTN BWP BYN BZD CAD CDF CHF CLP CNY COP CRC CUC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SLL SOS SRD SSP STN SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VUV WST XAF XCD XCG XDR XOF XPF XSU YER ZAR ZMW ZWG ZWL'.split(' '));
+const ISO_4217_CODES = (() => {
+    const supportedValuesOf = Intl.supportedValuesOf;
+    if (typeof supportedValuesOf === 'function') {
+        try {
+            return new Set([...FALLBACK_ISO_4217_CODES, ...supportedValuesOf.call(Intl, 'currency')]);
+        }
+        catch {
+            // Use the embedded list on runtimes without currency enumeration.
+        }
+    }
+    return FALLBACK_ISO_4217_CODES;
+})();
+const SYSTEM_FIELD_SQL = {
+    'sys.title': 'n.title',
+    'sys.created_at': 'n.created_at',
+    'sys.updated_at': 'n.updated_at',
+    'sys.tags': 'n.tags',
+    'sys.zettel_boxes': 'n.zettel_boxes',
+    'sys.source': 'n.source',
+    'sys.type': 'n.type',
+    'sys.starred_at': 'n.starred_at',
+};
+const TEXT_FILTER_OPERATORS = new Set([
+    'equals',
+    'notEquals',
+    'contains',
+    'notContains',
+    'isEmpty',
+    'isNotEmpty',
+]);
+const LIST_FILTER_OPERATORS = new Set([
+    'contains',
+    'notContains',
+    'isEmpty',
+    'isNotEmpty',
+]);
+const SELECT_FILTER_OPERATORS = new Set([
+    'equals',
+    'notEquals',
+    'isEmpty',
+    'isNotEmpty',
+]);
+const ORDERABLE_FILTER_OPERATORS = new Set([
+    'equals',
+    'notEquals',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'isEmpty',
+    'isNotEmpty',
+]);
+const BOOLEAN_FILTER_OPERATORS = new Set([
+    'equals',
+    'notEquals',
+    'isEmpty',
+    'isNotEmpty',
+]);
+export const SYSTEM_FIELD_SEMANTICS = {
+    'sys.title': { type: 'text' },
+    'sys.created_at': { type: 'date', dateMode: 'datetime' },
+    'sys.updated_at': { type: 'date', dateMode: 'datetime' },
+    'sys.tags': { type: 'list', propertyType: 'multi_select' },
+    'sys.zettel_boxes': { type: 'list', propertyType: 'relation' },
+    'sys.source': { type: 'text' },
+    'sys.type': { type: 'text' },
+    'sys.starred_at': { type: 'date', dateMode: 'datetime' },
+};
+const SYSTEM_FIELD_PROPERTY_TYPES = {
+    'sys.title': 'text',
+    'sys.created_at': 'date',
+    'sys.updated_at': 'date',
+    'sys.tags': 'multi_select',
+    'sys.zettel_boxes': 'relation',
+    'sys.source': 'text',
+    'sys.type': 'text',
+    'sys.starred_at': 'date',
+};
+const SYSTEM_FIELD_NAMES = {
+    'sys.title': 'Title',
+    'sys.created_at': 'Created at',
+    'sys.updated_at': 'Updated at',
+    'sys.tags': 'Tags',
+    'sys.zettel_boxes': 'Zettel boxes',
+    'sys.source': 'Source',
+    'sys.type': 'Type',
+    'sys.starred_at': 'Starred at',
+};
+function savedViewError(code, message, details) {
+    return new DinoxError(message, {
+        code,
+        details,
+        recoverable: false,
+    });
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPropertyType(value) {
+    return typeof value === 'string' && PROPERTY_TYPES.has(value);
+}
+function normalizePropertyOptionLabel(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.normalize('NFKC').trim();
+    return normalized && normalized.length <= 120 ? normalized : null;
+}
+function parsePropertyOptions(raw) {
+    if (!raw?.trim()) {
+        throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_MIGRATION_REQUIRED', 'Saved view select fields require migrated version 1 property options');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_INVALID', 'Saved view property options are invalid');
+    }
+    if (Array.isArray(parsed)) {
+        throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_MIGRATION_REQUIRED', 'Saved view select fields require migrated version 1 property options');
+    }
+    if (!isRecord(parsed) || parsed.version !== 1 || !Array.isArray(parsed.items) || parsed.items.length > 200) {
+        throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_INVALID', 'Saved view property options are invalid');
+    }
+    const ids = new Set();
+    const labels = new Set();
+    const options = [];
+    for (const item of parsed.items) {
+        if (!isRecord(item)) {
+            throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_INVALID', 'Saved view property options are invalid');
+        }
+        const id = typeof item.id === 'string' ? item.id : '';
+        const label = normalizePropertyOptionLabel(item.label);
+        const labelKey = label?.toLowerCase() ?? '';
+        if (!id.trim()
+            || id.trim() !== id
+            || !label
+            || !PROPERTY_OPTION_COLORS.has(String(item.color))
+            || !Number.isSafeInteger(item.sortRank)
+            || typeof item.archived !== 'boolean'
+            || ids.has(id)
+            || labels.has(labelKey)) {
+            throw savedViewError('SAVED_VIEW_PROPERTY_OPTIONS_INVALID', 'Saved view property options are invalid');
+        }
+        ids.add(id);
+        labels.add(labelKey);
+        options.push({
+            id,
+            label,
+            color: String(item.color),
+            sortRank: item.sortRank,
+            archived: item.archived,
+        });
+    }
+    return options.sort((left, right) => left.sortRank - right.sortRank || left.id.localeCompare(right.id));
+}
+function optionalFiniteNumber(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const candidate = value[key];
+    return typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : null;
+}
+function optionalConfigText(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const candidate = value[key];
+    if (typeof candidate !== 'string')
+        return null;
+    const normalized = candidate.normalize('NFKC').trim();
+    return normalized && normalized.length <= 120 ? normalized : null;
+}
+function parsePropertyConfig(raw, type) {
+    if (!raw?.trim()) {
+        return type === 'date' ? { dateMode: 'date' } : {};
+    }
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+    }
+    if (!isRecord(value) || value.version !== 1 || value.type !== type) {
+        throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+    }
+    switch (type) {
+        case 'date':
+            if (value.mode !== 'date' && value.mode !== 'datetime') {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            return { dateMode: value.mode };
+        case 'number': {
+            if (value.format !== 'number' && value.format !== 'percent' && value.format !== 'currency') {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            const precision = optionalFiniteNumber(value, 'precision');
+            const min = optionalFiniteNumber(value, 'min');
+            const max = optionalFiniteNumber(value, 'max');
+            const step = optionalFiniteNumber(value, 'step');
+            const currency = optionalConfigText(value, 'currency');
+            const unit = optionalConfigText(value, 'unit');
+            const normalizedCurrency = currency?.toUpperCase();
+            if (precision === null
+                || min === null
+                || max === null
+                || step === null
+                || currency === null
+                || unit === null
+                || (precision !== undefined && (!Number.isSafeInteger(precision) || precision < 0 || precision > 12))
+                || (step !== undefined && step <= 0)
+                || (min !== undefined && max !== undefined && min > max)
+                || (normalizedCurrency !== undefined && !ISO_4217_CODES.has(normalizedCurrency))
+                || (value.format === 'currency' && currency === undefined)) {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            return {};
+        }
+        case 'select':
+            if (value.mode !== 'open' && value.mode !== 'closed') {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            return {};
+        case 'multi_select': {
+            const maxSelections = optionalFiniteNumber(value, 'maxSelections');
+            if ((value.mode !== 'open' && value.mode !== 'closed')
+                || maxSelections === null
+                || (maxSelections !== undefined && (!Number.isSafeInteger(maxSelections) || maxSelections < 1 || maxSelections > 50))) {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            return {};
+        }
+        case 'url':
+            if (Object.hasOwn(value, 'schemes')
+                && (!Array.isArray(value.schemes)
+                    || value.schemes.length === 0
+                    || value.schemes.some((scheme) => scheme !== 'http' && scheme !== 'https'))) {
+                throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+            }
+            return {};
+        default:
+            throw savedViewError('SAVED_VIEW_PROPERTY_CONFIG_INVALID', 'Saved view property config is invalid');
+    }
+}
+function propertyDefToSemantic(row, type) {
+    const config = parsePropertyConfig(row.config_json, type);
+    switch (type) {
+        case 'number':
+            return { type: 'number', propertyType: type };
+        case 'date':
+            return { type: 'date', propertyType: type, dateMode: config.dateMode ?? 'date' };
+        case 'select':
+            return { type: 'select', propertyType: type, options: parsePropertyOptions(row.options) };
+        case 'checkbox':
+            return { type: 'boolean', propertyType: type };
+        case 'multi_select':
+            return { type: 'list', propertyType: type, options: parsePropertyOptions(row.options) };
+        case 'relation':
+            return { type: 'list', propertyType: type };
+        default:
+            return { type: 'text', propertyType: type };
+    }
+}
+function fallbackPropertySemantic(type) {
+    switch (type) {
+        case 'number': return { type: 'number', propertyType: type };
+        case 'date': return { type: 'date', propertyType: type, dateMode: 'date' };
+        case 'select': return { type: 'select', propertyType: type };
+        case 'checkbox': return { type: 'boolean', propertyType: type };
+        case 'multi_select':
+        case 'relation': return { type: 'list', propertyType: type };
+        default: return { type: 'text', propertyType: type };
+    }
+}
+function propertySemanticQuery(keys) {
+    const keyClause = keys && keys.length > 0
+        ? `AND key IN (${keys.map(() => '?').join(', ')})`
+        : '';
+    return {
+        sql: `
+      SELECT
+        ranked.id,
+        ranked.key,
+        ranked.name,
+        ranked.type,
+        ranked.options,
+        ranked.description,
+        ranked.icon,
+        ranked.sort_rank,
+        (
+          SELECT cp.c_value
+          FROM c_config_property AS cp
+          WHERE cp.user_id = ranked.user_id
+            AND cp.c_key = '${PROPERTY_DEF_CONFIG_KEY_PREFIX}' || ranked.id
+            AND (cp.is_del IS NULL OR cp.is_del = 0)
+          ORDER BY COALESCE(cp.updated_at, cp.created_at, cp.id) DESC, cp.id DESC
+          LIMIT 1
+        ) AS config_json
+      FROM (
+        SELECT
+          id,
+          user_id,
+          key,
+          name,
+          type,
+          options,
+          description,
+          icon,
+          sort_rank,
+          ROW_NUMBER() OVER (
+            PARTITION BY key
+            ORDER BY COALESCE(NULLIF(updated_at, ''), NULLIF(created_at, ''), id) DESC, id DESC
+          ) AS key_rank
+        FROM c_property_def
+        WHERE user_id = ?
+          ${keyClause}
+          AND (is_del IS NULL OR is_del = 0)
+      ) AS ranked
+      WHERE ranked.key_rank = 1
+      ORDER BY COALESCE(ranked.sort_rank, 0) ASC, ranked.key ASC, ranked.id ASC
+    `,
+        params: [...(keys ?? [])],
+    };
+}
+async function loadPropertySemanticRows(db, userId, keys) {
+    const query = propertySemanticQuery(keys);
+    return db.getAll(query.sql, [userId, ...query.params]);
+}
+function collectFilterConditions(node, conditions) {
+    if (!node)
+        return;
+    if (node.kind === 'condition') {
+        conditions.push(node);
+        return;
+    }
+    if (node.kind === 'not') {
+        collectFilterConditions(node.child, conditions);
+        return;
+    }
+    for (const child of node.children) {
+        collectFilterConditions(child, conditions);
+    }
+}
+function filterOperatorsForSemantic(semantic) {
+    if (semantic.type === 'text')
+        return TEXT_FILTER_OPERATORS;
+    if (semantic.type === 'select')
+        return SELECT_FILTER_OPERATORS;
+    if (semantic.type === 'list')
+        return LIST_FILTER_OPERATORS;
+    if (semantic.type === 'boolean')
+        return BOOLEAN_FILTER_OPERATORS;
+    return ORDERABLE_FILTER_OPERATORS;
+}
+function assertConditionSemantics(condition, semantic) {
+    if (!filterOperatorsForSemantic(semantic).has(condition.operator)) {
+        throw savedViewError('SAVED_VIEW_OPERATOR_TYPE_MISMATCH', `Operator ${condition.operator} is not supported for ${condition.field}`, { field: condition.field, operator: condition.operator, semanticType: semantic.type });
+    }
+    const value = condition.value;
+    if (value === undefined || value === null)
+        return;
+    if (semantic.type === 'number' && typeof value !== 'number') {
+        throw savedViewError('SAVED_VIEW_VALUE_TYPE_MISMATCH', `Filter value for ${condition.field} must be a number`);
+    }
+    if (semantic.type === 'boolean' && typeof value !== 'boolean') {
+        throw savedViewError('SAVED_VIEW_VALUE_TYPE_MISMATCH', `Filter value for ${condition.field} must be a boolean`);
+    }
+    if ((semantic.type === 'text' || semantic.type === 'select' || semantic.type === 'list' || semantic.type === 'date')
+        && typeof value !== 'string') {
+        throw savedViewError('SAVED_VIEW_VALUE_TYPE_MISMATCH', `Filter value for ${condition.field} must be a string`);
+    }
+    if (semantic.type === 'date'
+        && typeof value === 'string'
+        && normalizeDatePropertyValue(value, semantic.dateMode ?? 'date') === null) {
+        throw savedViewError('SAVED_VIEW_INVALID_DATE_VALUE', `Filter value for ${condition.field} is not a valid date`);
+    }
+    if ((semantic.propertyType === 'select' || semantic.propertyType === 'multi_select')
+        && typeof value === 'string'
+        && !(semantic.options ?? []).some((option) => option.id === value)) {
+        throw savedViewError('SAVED_VIEW_OPTION_NOT_FOUND', `Filter option ${value} does not exist for ${condition.field}`, { field: condition.field, optionId: value });
+    }
+}
+export async function validateSavedViewSemantics(db, userId, filter, config) {
+    const conditions = [];
+    collectFilterConditions(filter?.root ?? null, conditions);
+    const fields = new Set();
+    for (const condition of conditions)
+        fields.add(condition.field);
+    for (const column of config?.columns ?? [])
+        fields.add(column.field);
+    for (const sort of config?.sort ?? [])
+        fields.add(sort.field);
+    const propertyKeys = [...new Set([...fields]
+            .filter((field) => field.startsWith('prop.'))
+            .map((field) => field.slice('prop.'.length)))];
+    const propertySemantics = new Map();
+    if (propertyKeys.length > 0) {
+        const rows = await loadPropertySemanticRows(db, userId, propertyKeys);
+        for (const row of rows) {
+            if (row.key && isPropertyType(row.type)) {
+                propertySemantics.set(row.key, propertyDefToSemantic(row, row.type));
+            }
+        }
+        for (const key of propertyKeys) {
+            if (!propertySemantics.has(key)) {
+                throw savedViewError('SAVED_VIEW_PROPERTY_NOT_FOUND', `Saved view property definition not found: ${key}`, { propertyKey: key });
+            }
+        }
+    }
+    const semantics = new Map();
+    for (const field of fields) {
+        const semantic = field.startsWith('prop.')
+            ? propertySemantics.get(field.slice('prop.'.length))
+            : SYSTEM_FIELD_SEMANTICS[field];
+        if (!semantic) {
+            throw savedViewError('SAVED_VIEW_INVALID_FIELD', `Saved view field is invalid: ${field}`, { field });
+        }
+        semantics.set(field, semantic);
+    }
+    for (const condition of conditions) {
+        assertConditionSemantics(condition, semantics.get(condition.field));
+    }
+    for (const sort of config?.sort ?? []) {
+        if (semantics.get(sort.field)?.type === 'list') {
+            throw savedViewError('SAVED_VIEW_SORT_TYPE_UNSUPPORTED', `Saved view field cannot be sorted: ${sort.field}`, { field: sort.field });
+        }
+    }
+    return semantics;
+}
+const ISO_DATE_PREFIX_PATTERN = /^([+-]?\d{4,6})-(\d{2})-(\d{2})(?:$|[Tt\s])/;
+function hasValidCalendarDatePrefix(value) {
+    const match = ISO_DATE_PREFIX_PATTERN.exec(value);
+    if (!match)
+        return true;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (!Number.isInteger(year) || month < 1 || month > 12 || day < 1)
+        return false;
+    const daysInMonth = [
+        31,
+        year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+    ];
+    return day <= (daysInMonth[month - 1] ?? 0);
+}
+function normalizeDateValueToIso(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed || !hasValidCalendarDatePrefix(trimmed))
+            return null;
+        const date = new Date(trimmed);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    return null;
+}
+export function normalizeDatePropertyValue(value, mode) {
+    if (mode === 'datetime')
+        return normalizeDateValueToIso(value);
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (/^(\d{4})-(\d{2})-(\d{2})$/.test(trimmed)) {
+            return hasValidCalendarDatePrefix(trimmed) ? trimmed : null;
+        }
+    }
+    return normalizeDateValueToIso(value)?.slice(0, 10) ?? null;
+}
+export function normalizeSavedViewDateValues(filter, semantics) {
+    const normalizeNode = (node) => {
+        if (node.kind === 'condition') {
+            const semantic = semantics.get(node.field);
+            if (semantic?.type === 'date' && typeof node.value === 'string') {
+                const normalized = normalizeDatePropertyValue(node.value, semantic.dateMode ?? 'date');
+                if (!normalized) {
+                    throw savedViewError('SAVED_VIEW_INVALID_DATE_VALUE', `Filter value for ${node.field} is not a valid date`);
+                }
+                return { ...node, value: normalized };
+            }
+            return node;
+        }
+        if (node.kind === 'not') {
+            return { ...node, child: normalizeNode(node.child) };
+        }
+        return { ...node, children: node.children.map(normalizeNode) };
+    };
+    return {
+        ...filter,
+        root: filter.root ? normalizeNode(filter.root) : null,
+    };
+}
+function propertyJsonPath(field) {
+    const key = field.slice('prop.'.length);
+    const escaped = key.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+    return `$."${escaped}"`;
+}
+export function compileSavedViewField(field) {
+    const systemSql = SYSTEM_FIELD_SQL[field];
+    if (systemSql)
+        return { sql: systemSql, params: [] };
+    if (!field.startsWith('prop.') || field.length <= 'prop.'.length) {
+        throw savedViewError('SAVED_VIEW_INVALID_FIELD', `Saved view field is invalid: ${field}`);
+    }
+    return {
+        sql: "json_extract(CASE WHEN json_valid(n.properties) THEN n.properties ELSE '{}' END, ?)",
+        params: [propertyJsonPath(field)],
+    };
+}
+function requireConditionValue(condition) {
+    if (condition.value === undefined || condition.value === null) {
+        throw savedViewError('SAVED_VIEW_FILTER_VALUE_REQUIRED', `Operator ${condition.operator} requires a value`);
+    }
+    return condition.value;
+}
+function normalizeSqlParameter(value) {
+    return typeof value === 'boolean' ? (value ? 1 : 0) : value;
+}
+function compileEmptyCheck(field, empty) {
+    const emptySql = `(${field.sql} IS NULL OR trim(CAST(${field.sql} AS TEXT)) = '' OR CAST(${field.sql} AS TEXT) = '[]')`;
+    return {
+        sql: empty ? emptySql : `(NOT ${emptySql})`,
+        params: [...field.params, ...field.params, ...field.params],
+    };
+}
+function comparison(field, operator, value, semantic, nullResult = 0) {
+    const isDate = semantic?.type === 'date';
+    const dateFunction = semantic?.dateMode === 'datetime' || (operator !== '=' && operator !== '!=')
+        ? 'julianday'
+        : 'date';
+    const left = isDate
+        ? `${dateFunction}(${field.sql})`
+        : semantic?.type === 'number'
+            ? `CAST(${field.sql} AS REAL)`
+            : field.sql;
+    const right = isDate
+        ? `${dateFunction}(?)`
+        : semantic?.type === 'number'
+            ? 'CAST(? AS REAL)'
+            : '?';
+    return {
+        sql: `COALESCE((${left} ${operator} ${right}), ${nullResult})`,
+        params: [...field.params, normalizeSqlParameter(value)],
+    };
+}
+function compileContains(field, value, negated, semantic) {
+    const normalizedValue = normalizeSqlParameter(value);
+    if (semantic?.type !== 'list') {
+        const predicate = `COALESCE(
+      instr(lower(CAST(${field.sql} AS TEXT)), lower(CAST(? AS TEXT))) > 0,
+      0
+    )`;
+        return {
+            sql: negated ? `(NOT (${predicate}))` : predicate,
+            params: [...field.params, normalizedValue],
+        };
+    }
+    const predicate = `EXISTS (
+    SELECT 1
+    FROM (SELECT ${field.sql} AS field_value) AS saved_view_field
+    WHERE json_valid(CAST(saved_view_field.field_value AS TEXT))
+      AND json_type(CAST(saved_view_field.field_value AS TEXT)) = 'array'
+      AND EXISTS (
+        SELECT 1
+        FROM json_each(CAST(saved_view_field.field_value AS TEXT)) AS saved_view_item
+        WHERE CAST(saved_view_item.value AS TEXT) = CAST(? AS TEXT)
+      )
+  )`;
+    return {
+        sql: negated ? `(NOT (${predicate}))` : predicate,
+        params: [...field.params, normalizedValue],
+    };
+}
+function compileCondition(condition, semantics) {
+    const field = compileSavedViewField(condition.field);
+    const value = condition.value;
+    const semantic = semantics?.get(condition.field) ?? SYSTEM_FIELD_SEMANTICS[condition.field];
+    switch (condition.operator) {
+        case 'equals':
+            return value === undefined || value === null
+                ? compileEmptyCheck(field, true)
+                : comparison(field, '=', value, semantic, 0);
+        case 'notEquals':
+            return value === undefined || value === null
+                ? compileEmptyCheck(field, false)
+                : comparison(field, '!=', value, semantic, 1);
+        case 'contains':
+            return compileContains(field, requireConditionValue(condition), false, semantic);
+        case 'notContains':
+            return compileContains(field, requireConditionValue(condition), true, semantic);
+        case 'greaterThan':
+            return comparison(field, '>', requireConditionValue(condition), semantic);
+        case 'greaterThanOrEqual':
+            return comparison(field, '>=', requireConditionValue(condition), semantic);
+        case 'lessThan':
+            return comparison(field, '<', requireConditionValue(condition), semantic);
+        case 'lessThanOrEqual':
+            return comparison(field, '<=', requireConditionValue(condition), semantic);
+        case 'isEmpty':
+            return compileEmptyCheck(field, true);
+        case 'isNotEmpty':
+            return compileEmptyCheck(field, false);
+    }
+}
+function compileFilterNode(node, budget, depth, semantics) {
+    budget.nodes += 1;
+    if (depth > 8 || budget.nodes > 100) {
+        throw savedViewError('SAVED_VIEW_FILTER_TOO_COMPLEX', 'Saved view filter is too complex');
+    }
+    if (node.kind === 'condition')
+        return compileCondition(node, semantics);
+    if (node.kind === 'not') {
+        const child = compileFilterNode(node.child, budget, depth + 1, semantics);
+        return { sql: `(NOT (${child.sql}))`, params: child.params };
+    }
+    const children = node.children.map((child) => compileFilterNode(child, budget, depth + 1, semantics));
+    if (children.length === 0)
+        return { sql: node.operator === 'and' ? '1' : '0', params: [] };
+    return {
+        sql: `(${children.map((child) => `(${child.sql})`).join(node.operator === 'and' ? ' AND ' : ' OR ')})`,
+        params: children.flatMap((child) => child.params),
+    };
+}
+export function compileSavedViewFilter(filter, semantics) {
+    return filter.root
+        ? compileFilterNode(filter.root, { nodes: 0 }, 1, semantics)
+        : { sql: '1', params: [] };
+}
+export function compileSavedViewOrder(config, semantics) {
+    const clauses = [];
+    const params = [];
+    for (const sort of config.sort ?? []) {
+        const field = compileSavedViewField(sort.field);
+        const direction = sort.direction === 'asc' ? 'ASC' : 'DESC';
+        const semantic = semantics?.get(sort.field) ?? SYSTEM_FIELD_SEMANTICS[sort.field];
+        if (semantic?.type === 'list') {
+            throw savedViewError('SAVED_VIEW_SORT_TYPE_UNSUPPORTED', `Saved view field cannot be sorted: ${sort.field}`);
+        }
+        clauses.push(`CASE WHEN ${field.sql} IS NULL OR trim(CAST(${field.sql} AS TEXT)) = '' THEN 1 ELSE 0 END ASC`);
+        params.push(...field.params, ...field.params);
+        if (semantic?.type === 'select' && (semantic.options?.length ?? 0) > 0) {
+            const options = [...(semantic.options ?? [])].sort((left, right) => left.sortRank - right.sortRank || left.id.localeCompare(right.id));
+            clauses.push(`CASE WHEN ${field.sql} IN (${options.map(() => '?').join(', ')}) THEN 0 ELSE 1 END ASC`, `CASE ${field.sql} ${options.map(() => 'WHEN ? THEN ?').join(' ')} ELSE NULL END ${direction}`, `${field.sql} COLLATE NOCASE ${direction}`);
+            params.push(...field.params, ...options.map((option) => option.id), ...field.params, ...options.flatMap((option) => [option.id, option.sortRank]), ...field.params);
+            continue;
+        }
+        const expression = semantic?.type === 'date'
+            ? `julianday(${field.sql})`
+            : semantic?.type === 'number'
+                ? `CAST(${field.sql} AS REAL)`
+                : `${field.sql} COLLATE NOCASE`;
+        clauses.push(`${expression} ${direction}`);
+        params.push(...field.params);
+    }
+    if (clauses.length === 0)
+        clauses.push('COALESCE(n.updated_at, n.created_at, n.id) DESC');
+    clauses.push('n.id DESC');
+    return { sql: clauses.join(', '), params };
+}
+function catalogItem(field, name, propertyType, semantic, extra = {}) {
+    return {
+        field,
+        name,
+        type: semantic.type,
+        propertyType,
+        sortable: semantic.type !== 'list',
+        filterOperators: [...filterOperatorsForSemantic(semantic)],
+        available: true,
+        ...(semantic.options ? { options: semantic.options } : {}),
+        ...extra,
+    };
+}
+export async function listSavedViewFields(db, userId) {
+    const systemItems = SAVED_VIEW_SYSTEM_FIELDS.map((name) => {
+        const field = `sys.${name}`;
+        return catalogItem(field, SYSTEM_FIELD_NAMES[field] ?? name, SYSTEM_FIELD_PROPERTY_TYPES[field] ?? 'text', SYSTEM_FIELD_SEMANTICS[field]);
+    });
+    const rows = await loadPropertySemanticRows(db, userId);
+    const propertyItems = [];
+    for (const row of rows) {
+        if (!row.id?.trim() || !row.key?.trim() || !isPropertyType(row.type))
+            continue;
+        const field = `prop.${row.key}`;
+        const extra = {
+            propertyDefinitionId: row.id,
+            description: row.description,
+            icon: row.icon,
+        };
+        try {
+            propertyItems.push(catalogItem(field, row.name?.trim() || row.key, row.type, propertyDefToSemantic(row, row.type), extra));
+        }
+        catch (error) {
+            propertyItems.push({
+                ...catalogItem(field, row.name?.trim() || row.key, row.type, fallbackPropertySemantic(row.type), extra),
+                available: false,
+                error: {
+                    code: error instanceof DinoxError ? error.code : 'SAVED_VIEW_PROPERTY_INVALID',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    return [...systemItems, ...propertyItems];
+}