@lapis-notes/bases 0.1.0

package/dist/bases-view/document-core.js

@@ -0,0 +1,166 @@
+function emptyFilter() {
+    return { and: [] };
+}
+function defaultTableView() {
+    return {
+        type: "table",
+        name: "Table",
+        layout: "table",
+        order: [],
+        sort: [],
+        filter: emptyFilter(),
+        limit: 0,
+        columnSize: {},
+        imageAspectRatio: 1,
+    };
+}
+function defaultCardsView() {
+    return {
+        type: "cards",
+        name: "Cards",
+        order: [],
+        sort: [],
+        filter: emptyFilter(),
+        limit: 0,
+        image: "",
+        imageFit: "contain",
+        imageAspectRatio: 1,
+        cardSize: 200,
+    };
+}
+function defaultCustomView(type) {
+    return {
+        type,
+        name: type,
+        order: [],
+        sort: [],
+        filter: emptyFilter(),
+        limit: 0,
+    };
+}
+function normalizeView(view, fallbackName) {
+    if (!view || typeof view !== "object")
+        return null;
+    const candidate = view;
+    if (candidate.type === "table") {
+        return {
+            ...defaultTableView(),
+            ...candidate,
+            name: typeof candidate.name === "string" ? candidate.name : fallbackName,
+            order: Array.isArray(candidate.order)
+                ? candidate.order.filter((value) => typeof value === "string")
+                : [],
+            sort: Array.isArray(candidate.sort) ? candidate.sort : [],
+            filter: candidate.filter && typeof candidate.filter === "object"
+                ? candidate.filter
+                : emptyFilter(),
+            limit: typeof candidate.limit === "number" ? candidate.limit : 0,
+            columnSize: candidate.columnSize && typeof candidate.columnSize === "object"
+                ? candidate.columnSize
+                : {},
+            imageAspectRatio: typeof candidate.imageAspectRatio === "number"
+                ? candidate.imageAspectRatio
+                : 1,
+        };
+    }
+    if (candidate.type === "cards") {
+        return {
+            ...defaultCardsView(),
+            ...candidate,
+            name: typeof candidate.name === "string" ? candidate.name : fallbackName,
+            order: Array.isArray(candidate.order)
+                ? candidate.order.filter((value) => typeof value === "string")
+                : [],
+            sort: Array.isArray(candidate.sort) ? candidate.sort : [],
+            filter: candidate.filter && typeof candidate.filter === "object"
+                ? candidate.filter
+                : emptyFilter(),
+            limit: typeof candidate.limit === "number" ? candidate.limit : 0,
+            summaries: candidate.summaries && typeof candidate.summaries === "object"
+                ? candidate.summaries
+                : undefined,
+            groupBy: candidate.groupBy && typeof candidate.groupBy === "object"
+                ? candidate.groupBy
+                : undefined,
+            image: typeof candidate.image === "string" ? candidate.image : "",
+            imageFit: candidate.imageFit === "cover" || candidate.imageFit === "contain"
+                ? candidate.imageFit
+                : "contain",
+            imageAspectRatio: typeof candidate.imageAspectRatio === "number"
+                ? candidate.imageAspectRatio
+                : 1,
+            cardSize: typeof candidate.cardSize === "number" ? candidate.cardSize : 200,
+        };
+    }
+    if (candidate.type === "list" || candidate.type === "map") {
+        return {
+            type: candidate.type,
+            name: typeof candidate.name === "string" ? candidate.name : fallbackName,
+            order: Array.isArray(candidate.order)
+                ? candidate.order.filter((value) => typeof value === "string")
+                : [],
+            sort: Array.isArray(candidate.sort) ? candidate.sort : [],
+            filter: candidate.filter && typeof candidate.filter === "object"
+                ? candidate.filter
+                : emptyFilter(),
+            limit: typeof candidate.limit === "number" ? candidate.limit : 0,
+            summaries: candidate.summaries && typeof candidate.summaries === "object"
+                ? candidate.summaries
+                : undefined,
+            groupBy: candidate.groupBy && typeof candidate.groupBy === "object"
+                ? candidate.groupBy
+                : undefined,
+        };
+    }
+    if (typeof candidate.type === "string" && candidate.type.length > 0) {
+        return {
+            ...defaultCustomView(candidate.type),
+            ...candidate,
+            name: typeof candidate.name === "string" ? candidate.name : fallbackName,
+            order: Array.isArray(candidate.order)
+                ? candidate.order.filter((value) => typeof value === "string")
+                : [],
+            sort: Array.isArray(candidate.sort) ? candidate.sort : [],
+            filter: candidate.filter && typeof candidate.filter === "object"
+                ? candidate.filter
+                : emptyFilter(),
+            limit: typeof candidate.limit === "number" ? candidate.limit : 0,
+            summaries: candidate.summaries && typeof candidate.summaries === "object"
+                ? candidate.summaries
+                : undefined,
+            groupBy: candidate.groupBy && typeof candidate.groupBy === "object"
+                ? candidate.groupBy
+                : undefined,
+        };
+    }
+    return null;
+}
+export function normalizeBasesDocument(input) {
+    const candidate = input && typeof input === "object" ? input : {};
+    const views = Array.isArray(candidate.views)
+        ? candidate.views
+            .map((view, index) => normalizeView(view, `View ${index + 1}`))
+            .filter((view) => !!view)
+        : [];
+    const normalizedViews = views.length ? views : [defaultTableView()];
+    const activeView = typeof candidate.activeView === "string" &&
+        normalizedViews.some((view) => view.name === candidate.activeView)
+        ? candidate.activeView
+        : normalizedViews[0].name;
+    return {
+        filters: candidate.filters && typeof candidate.filters === "object"
+            ? candidate.filters
+            : emptyFilter(),
+        properties: candidate.properties && typeof candidate.properties === "object"
+            ? candidate.properties
+            : {},
+        formulas: candidate.formulas && typeof candidate.formulas === "object"
+            ? candidate.formulas
+            : {},
+        summaries: candidate.summaries && typeof candidate.summaries === "object"
+            ? candidate.summaries
+            : {},
+        activeView,
+        views: normalizedViews,
+    };
+}

package/dist/bases-view/export-core.d.ts

@@ -0,0 +1,4 @@
+export type ExportableEntry<TPropertyId extends string> = {
+    getValue(propertyId: TPropertyId): unknown;
+};
+export declare function serializeResultsToCsv<TPropertyId extends string>(entries: Array<ExportableEntry<TPropertyId>>, properties: TPropertyId[], displayName: (propertyId: TPropertyId) => string): string;

package/dist/bases-view/export-core.js

@@ -0,0 +1,31 @@
+function stringifyValue(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "object" &&
+        value &&
+        "value" in value) {
+        const inner = value.value;
+        return inner === null || inner === undefined ? "" : String(inner);
+    }
+    return String(value);
+}
+function escapeCsv(value) {
+    if (!/[",\n]/.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll('"', '""')}"`;
+}
+export function serializeResultsToCsv(entries, properties, displayName) {
+    const lines = [
+        properties
+            .map((propertyId) => escapeCsv(displayName(propertyId)))
+            .join(","),
+    ];
+    for (const entry of entries) {
+        lines.push(properties
+            .map((propertyId) => escapeCsv(stringifyValue(entry.getValue(propertyId))))
+            .join(","));
+    }
+    return lines.join("\n");
+}

package/dist/bases-view/file-fields-core.d.ts

@@ -0,0 +1,31 @@
+import type { MetadataType } from "@lapis-notes/api";
+export type FileColumnDefinition = {
+    id: string;
+    displayName: string;
+    icon: string;
+    type: MetadataType;
+};
+export type FileMetadataCache = {
+    frontmatter?: Record<string, unknown>;
+    links?: Array<{
+        link: string;
+    }>;
+    embeds?: Array<{
+        link: string;
+    }>;
+    tags?: Array<{
+        tag: string;
+    }>;
+} | null | undefined;
+export declare function buildFileColumns(properties?: Record<string, {
+    displayName: string;
+}>): FileColumnDefinition[];
+export declare function deriveFileMetadata(entryPath: string, cache: FileMetadataCache, backlinkInput?: string[] | Record<string, Record<string, number>>): {
+    tags: string[];
+    links: string[];
+    embeds: string[];
+    backlinks: string[];
+    properties: {
+        [x: string]: unknown;
+    };
+};

package/dist/bases-view/file-fields-core.js

@@ -0,0 +1,114 @@
+export function buildFileColumns(properties = {}) {
+    return [
+        {
+            id: "file",
+            displayName: properties["file"]?.displayName || "file",
+            icon: "lucide-file",
+            type: "file",
+        },
+        {
+            id: "file.name",
+            displayName: properties["file.name"]?.displayName || "file name",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.file",
+            displayName: properties["file.file"]?.displayName || "file reference",
+            icon: "lucide-file",
+            type: "file",
+        },
+        {
+            id: "file.ext",
+            displayName: properties["file.ext"]?.displayName || "file extension",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.basename",
+            displayName: properties["file.basename"]?.displayName || "file base name",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.folder",
+            displayName: properties["file.folder"]?.displayName || "folder",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.fullname",
+            displayName: properties["file.fullname"]?.displayName || "file full name",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.path",
+            displayName: properties["file.path"]?.displayName || "file path",
+            icon: "lucide-text",
+            type: "text",
+        },
+        {
+            id: "file.ctime",
+            displayName: properties["file.ctime"]?.displayName || "created time",
+            icon: "lucide-clock",
+            type: "datetime",
+        },
+        {
+            id: "file.mtime",
+            displayName: properties["file.mtime"]?.displayName || "modified time",
+            icon: "lucide-clock",
+            type: "datetime",
+        },
+        {
+            id: "file.size",
+            displayName: properties["file.size"]?.displayName || "file size",
+            icon: "lucide-binary",
+            type: "number",
+        },
+        {
+            id: "file.tags",
+            displayName: properties["file.tags"]?.displayName || "file tags",
+            icon: "lucide-tags",
+            type: "tags",
+        },
+        {
+            id: "file.links",
+            displayName: properties["file.links"]?.displayName || "file links",
+            icon: "lucide-link",
+            type: "multitext",
+        },
+        {
+            id: "file.embeds",
+            displayName: properties["file.embeds"]?.displayName || "file embeds",
+            icon: "lucide-image",
+            type: "multitext",
+        },
+        {
+            id: "file.backlinks",
+            displayName: properties["file.backlinks"]?.displayName || "file backlinks",
+            icon: "lucide-waypoints",
+            type: "multitext",
+        },
+        {
+            id: "file.properties",
+            displayName: properties["file.properties"]?.displayName || "file properties",
+            icon: "lucide-braces",
+            type: "unknown",
+        },
+    ];
+}
+export function deriveFileMetadata(entryPath, cache, backlinkInput = []) {
+    const backlinks = Array.isArray(backlinkInput)
+        ? backlinkInput
+        : Object.entries(backlinkInput)
+            .filter(([sourcePath, targets]) => sourcePath !== entryPath && Boolean(targets[entryPath]))
+            .map(([sourcePath]) => sourcePath);
+    return {
+        tags: (cache?.tags || []).map((it) => it.tag),
+        links: (cache?.links || []).map((it) => it.link),
+        embeds: (cache?.embeds || []).map((it) => it.link),
+        backlinks: backlinks.filter((sourcePath) => sourcePath !== entryPath),
+        properties: { ...(cache?.frontmatter || {}) },
+    };
+}

package/dist/bases-view/filter-parser.d.ts

@@ -0,0 +1,27 @@
+import { Expression } from "peaql";
+import { type BasesViewBase, type Filters } from "./models";
+import type { BasesPropertyId } from "@lapis-notes/api";
+export declare function isOp(op: string): boolean;
+export declare function parsePredicate(query: string): unknown;
+export declare const INVALID_FILTER_FORMULA_MESSAGE = "Invalid filter formula. Check the expression syntax.";
+export type FilterPredicateValidation = {
+    valid: true;
+    predicate: unknown;
+    error: null;
+} | {
+    valid: false;
+    predicate: null;
+    error: string;
+};
+export declare function validateFilterPredicate(query: string): FilterPredicateValidation;
+export declare function resolveFilterDraft(applied: string, draft: string): {
+    applied: string;
+    error: string | null;
+    valid: boolean;
+};
+export declare function normalizeFilter(filter: Filters): Filters;
+export declare function toSQL(filter: unknown, formulas?: Record<string, string>): string;
+export declare function resolveQuery(expr: Expression): unknown;
+export declare function isFilterColumn(column: string): [boolean, string, string];
+export declare function formulaColumn(name: string): BasesPropertyId;
+export declare function generateQuery(view: BasesViewBase, formulas: Record<string, string>, globalFilter?: Filters): string;

package/dist/bases-view/filter-parser.js

@@ -0,0 +1,315 @@
+import { AttributeExpression, BooleanExpression, ColumnExpression, Decimal, Expression, FunctionExpression, isNull, isValidNumber, LiteralExpression, parseQuery, Query, readString, SubscriptExpression, typeName, } from "peaql";
+import { filterGroupType, filterGroupValues, isFilterGroup, isFilterLine, } from "./models";
+import { isNumber } from "lodash-es";
+import { DateTime } from "luxon";
+const OPS = new Set([
+    ">",
+    "=",
+    "<",
+    "!=",
+    ">=",
+    "<=",
+    "~",
+    "~*",
+    "!~",
+    "!~*",
+    "?~",
+    "?~*",
+    "+",
+    "-",
+    "*",
+    "%",
+    "/",
+]);
+export function isOp(op) {
+    return OPS.has(op);
+}
+export function parsePredicate(query) {
+    if (!query)
+        return null;
+    const [expr] = parseQuery(`SELECT 1 WHERE ${query}`);
+    if (expr instanceof Query && expr.where) {
+        return resolveQuery(expr.where);
+    }
+}
+export const INVALID_FILTER_FORMULA_MESSAGE = "Invalid filter formula. Check the expression syntax.";
+export function validateFilterPredicate(query) {
+    if (!query.trim()) {
+        return { valid: true, predicate: null, error: null };
+    }
+    try {
+        const predicate = parsePredicate(query);
+        if (predicate) {
+            return { valid: true, predicate, error: null };
+        }
+    }
+    catch {
+        // The editor keeps the draft available for correction and reports one
+        // stable, user-facing message instead of leaking parser internals.
+    }
+    return {
+        valid: false,
+        predicate: null,
+        error: INVALID_FILTER_FORMULA_MESSAGE,
+    };
+}
+export function resolveFilterDraft(applied, draft) {
+    const validation = validateFilterPredicate(draft);
+    return {
+        applied: validation.valid ? draft : applied,
+        error: validation.error,
+        valid: validation.valid,
+    };
+}
+export function normalizeFilter(filter) {
+    const values = filterGroupValues(filter).slice();
+    values.forEach((value, i) => {
+        if (isFilterGroup(value)) {
+            normalizeFilter(value);
+        }
+    });
+    const type = filterGroupType(filter);
+    return {
+        [type]: values.filter((f) => {
+            if (typeof f === "string") {
+                return f.trim().length > 0;
+            }
+            return f;
+        }),
+    };
+}
+function toSQLValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value)) {
+        return value.map(toSQLValue).join(",");
+    }
+    if (typeof value === "string") {
+        value = readString(value);
+    }
+    else if (typeof value === "number" || value instanceof Decimal) {
+        if (!isNull(value) && isValidNumber(value.toString())) {
+            return new Decimal(value.toString()).number;
+        }
+    }
+    else if (value instanceof DateTime) {
+        value = value.toISO();
+    }
+    return JSON.stringify(value);
+}
+function replaceFormulas(query, formulas = {}) {
+    while (query.match(/formula\["([^"]*)"\]|filter\.[a-zA-Z_][a-zA-Z0-9_]*/g)) {
+        query = query.replaceAll(/formula\["([^"]*)"\]|filter\.[a-zA-Z_][a-zA-Z0-9_]*/g, (match, captured) => {
+            return formulas[captured] || "null";
+        });
+    }
+    return query;
+}
+export function toSQL(filter, formulas = {}) {
+    if (isFilterGroup(filter)) {
+        const type = filterGroupType(filter);
+        const values = filterGroupValues(filter)
+            .map((it) => toSQL(it, formulas))
+            .filter((it) => it.trim());
+        if (!values.length)
+            return "";
+        if (type === "not") {
+            return `NOT (${values.join(` OR `)})`;
+        }
+        return "(" + values.join(` ${type.toUpperCase()} `).trim() + ")";
+    }
+    else if (isFilterLine(filter)) {
+        const filt = filter;
+        if (filt.custom) {
+            return filt.custom;
+        }
+        if (filt.op &&
+            filt.column &&
+            (filter.value !== null || filt.value !== undefined)) {
+            let op = filter.op;
+            let column = filter.column;
+            const [isFilter, filterKey] = isFilterColumn(column);
+            if (isFilter) {
+                if (formulas && filterKey in formulas && formulas[filterKey]) {
+                    column = `(${formulas[filterKey]})`;
+                }
+            }
+            else if (column.match(/^[a-zA-Z0-9_.-]+\[[^\]]+\]$/)) {
+                column = column;
+            }
+            else if (!column.match(/^[a-zA-Z0-9_.-]+$/)) {
+                column = `{${column.replaceAll("}", "}}")}}`;
+            }
+            if (!OPS.has(op) && op.startsWith("!")) {
+                op = op.substring(1);
+                column = "!" + column;
+            }
+            if (OPS.has(op)) {
+                return `${column} ${op} ${toSQLValue(filt.value)}`;
+            }
+            const values = Array.isArray(filt.value) ? filt.value : [filt.value];
+            return `${column}.${op}(${toSQLValue(values)})`;
+        }
+    }
+    else if (typeof filter === "string") {
+        return replaceFormulas(filter, formulas);
+    }
+    return "";
+}
+function flattenBooleanExpression(expr, targetOp) {
+    const conditions = [];
+    for (const arg of expr.args) {
+        if (arg instanceof BooleanExpression && arg.op === targetOp) {
+            // Same operator - flatten recursively
+            conditions.push(...flattenBooleanExpression(arg, targetOp));
+        }
+        else {
+            // Different operator or non-boolean - resolve normally
+            conditions.push(resolveQuery(arg));
+        }
+    }
+    return conditions;
+}
+export function resolveQuery(expr) {
+    if (expr instanceof BooleanExpression) {
+        if (expr.args.length == 2) {
+            const [left, right] = expr.args;
+            const l = resolveQuery(left), r = resolveQuery(right);
+            if (typeof l === "string" &&
+                (right instanceof LiteralExpression || isScalar(r))) {
+                return { column: l, op: expr.op, value: r };
+            }
+        }
+        if (["AND", "OR", "NOT"].includes(expr.op)) {
+            const flattened = flattenBooleanExpression(expr, expr.op);
+            if (expr.op === "NOT" && flattened.length == 1) {
+                const value = flattened[0];
+                if (isFilterLine(value) && !value.custom) {
+                    if (!OPS.has(value.op)) {
+                        value.op = "!" + value.op;
+                        return value;
+                    }
+                }
+            }
+            return { [expr.op.toLowerCase()]: flattened };
+        }
+        return { column: "", op: expr.op, value: "", custom: expr.toString() };
+    }
+    else if (expr instanceof AttributeExpression) {
+        const op = resolveQuery(expr.operand);
+        if (typeof expr.name === "string" && typeof op == "string") {
+            return `${op}.${expr.name}`;
+        }
+        else if (typeof op === "string" && expr.name instanceof Expression) {
+            const value = resolveQuery(expr.name);
+            if (typeof value === "object") {
+                if (value && "custom" in value && value.custom) {
+                    return { column: op, value: "", ...value, custom: expr.toString() };
+                }
+                return { column: op, ...value };
+            }
+        }
+        else {
+            return { column: "", op: "", custom: expr.toString(), value: "" };
+        }
+    }
+    else if (expr instanceof ColumnExpression) {
+        return expr.name;
+    }
+    else if (expr instanceof LiteralExpression) {
+        return expr.value;
+    }
+    else if (expr instanceof FunctionExpression) {
+        if (expr.args.every((it) => {
+            return (it instanceof LiteralExpression || it instanceof ColumnExpression);
+        })) {
+            let values = expr.args.map((it) => resolveQuery(it));
+            if (values.length == 1) {
+                return { op: expr.name, value: values[0] };
+            }
+            return { op: expr.name, value: values };
+        }
+        return { op: expr.name, custom: expr.toString(), value: "" };
+    }
+    else if (expr instanceof SubscriptExpression) {
+        if (expr.operand instanceof ColumnExpression) {
+            return `${expr.operand.name}["${expr.key}"]`;
+        }
+    }
+    throw new Error(`Unsupported expression(${typeName(expr)}): ${expr}`);
+}
+function isScalar(value) {
+    const type = typeof value;
+    return ["string", "boolean", "number"].includes(type);
+}
+export function isFilterColumn(column) {
+    if (!column)
+        return [false, "", ""];
+    column = column.trim();
+    if (column.startsWith("formula.")) {
+        return [true, column.split(".", 2)[1], `{${column}}`];
+    }
+    else if (column.startsWith("formula[") && column.endsWith("]")) {
+        const id = readString(column.substring(8, column.length - 1));
+        return [true, id, `{formula.${id}}`];
+    }
+    return [false, "", ""];
+}
+export function formulaColumn(name) {
+    if (name.match(/^[a-zA-Z0-9_]+$/)) {
+        return `formula.${name}`;
+    }
+    return `formula[${JSON.stringify(name)}]`;
+}
+export function generateQuery(view, formulas, globalFilter) {
+    let query = "SET identifier_quoting = bracket;\nSELECT\n";
+    const columns = [
+        ...new Set([
+            ...view.order,
+            ...(view.groupBy?.property ? [view.groupBy.property] : []),
+            ...(typeof view.image === "string" && view.image.length > 0
+                ? [view.image]
+                : []),
+        ]),
+    ];
+    query += columns
+        .map((column) => {
+        const [isFilter, filterKey, filterColumn] = isFilterColumn(column);
+        if (isFilter) {
+            if (filterKey in formulas) {
+                if (formulas[filterKey]) {
+                    return `  (${replaceFormulas(formulas[filterKey], formulas)}) as ${filterColumn}`;
+                }
+            }
+            return `  null as ${filterColumn}`;
+        }
+        else if (column.match(/^[a-zA-Z0-9_.-]+$/)) {
+            return `  ${column} as {${column}}`;
+        }
+        return `  {${column}} as {${column}}`;
+    })
+        .join(",\n");
+    query += columns.length ? ",\n  rowId as {$rowId}" : "  rowId as {$rowId}";
+    const where = [toSQL(globalFilter, formulas), toSQL(view.filter, formulas)]
+        .filter((it) => it.length > 0)
+        .map((q) => `(${q})`)
+        .join(" and ");
+    if (where) {
+        query += "\nWHERE " + where;
+    }
+    const sort = view.sort
+        .map((s) => {
+        const [isFormula] = isFilterColumn(s.property);
+        return isFormula
+            ? `(${replaceFormulas(formulaColumn(s.property), formulas)}) ${s.direction}`
+            : `{${s.property}} ${s.direction}`;
+    })
+        .join(",");
+    if (sort.length) {
+        query += "\nORDER BY " + sort;
+    }
+    if (view.limit && view.limit > 0) {
+        query += "\nLIMIT " + view.limit;
+    }
+    return query;
+}