@sqlrooms/cells 0.29.0-rc.1 → 0.29.0-rc.2

package/dist/cellsSlice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cellsSlice.d.ts","sourceRoot":"","sources":["../src/cellsSlice.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAKV,iBAAiB,EACjB,eAAe,EAGhB,MAAM,SAAS,CAAC;AAgDjB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,mDA4uBxD"}
+{"version":3,"file":"cellsSlice.d.ts","sourceRoot":"","sources":["../src/cellsSlice.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAKV,iBAAiB,EACjB,eAAe,EAMhB,MAAM,SAAS,CAAC;AAoDjB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,mDA83BxD"}

package/dist/cellsSlice.js

@@ -2,13 +2,14 @@ import { createId } from '@paralleldrive/cuid2';
 import { makePagedQuery } from '@sqlrooms/data-table';
 import { sanitizeQuery } from '@sqlrooms/duckdb';
 import { createSlice } from '@sqlrooms/room-store';
-import { generateUniqueName } from '@sqlrooms/utils';
+import { convertToValidColumnOrTableName, generateUniqueName, } from '@sqlrooms/utils';
 import { produce } from 'immer';
-import { buildGraphCacheFromEdges, buildDependencyGraph, buildDependencyGraphAsync, collectReachable, ensureGraphCache, removeCellFromCache, replaceCellDependenciesInCache, topologicalOrder, } from './dagUtils';
+import { buildDependencyGraph, buildDependencyGraphAsync, buildGraphCacheFromEdges, collectReachable, ensureGraphCache, removeCellFromCache, replaceCellDependenciesInCache, topologicalOrder, } from './dagUtils';
 import { findSheetIdForCell, getRequiredSqlSelectToJson, normalizeCellsConfigStructure, resolveDependencies, } from './helpers';
 import { dropResultRelation } from './resultRelationPolicy';
 import { isInputCell, isSqlCell } from './types';
-import { getSheetSchemaName, isDefined } from './utils';
+import { getEffectiveResultName, getSheetSchemaName, isDefined } from './utils';
+import { buildCrossFilterPredicate } from './vegaSelectionUtils';
 function createDefaultCellsConfig(config) {
     const sheetId = createId();
     const defaultConfig = {
@@ -25,11 +26,13 @@ function createDefaultCellsConfig(config) {
                     dependencies: {},
                     dependents: {},
                     contentHashByCell: {},
+                    tableDependencies: {},
                 },
             },
         },
         sheetOrder: [sheetId],
         currentSheetId: sheetId,
+        tableDepSchemas: ['main'],
     };
     if (!config) {
         return defaultConfig;
@@ -50,16 +53,53 @@ export function createCellsSlice(props) {
     // Keep result data outside Immer drafts, but scoped per slice instance.
     const cellResultCache = new Map();
     return createSlice((set, get, store) => {
-        const dropSqlResultRelation = async (resultName) => {
+        const dropRelationBestEffort = async (relationName) => {
             try {
                 const connector = await get().db.getConnector();
-                await dropResultRelation({ connector, relationName: resultName });
+                await dropResultRelation({ connector, relationName });
             }
             catch {
-                // Best-effort cleanup: relation might already be gone or connector
-                // might be unavailable during teardown.
+                // Best-effort cleanup
             }
         };
+        const dropRelationsForStatus = async (cellType, status) => {
+            if (!status)
+                return;
+            const registryItem = cellRegistry[cellType];
+            const names = registryItem?.getRelationsToDrop?.(status) ?? [];
+            for (const name of names) {
+                await dropRelationBestEffort(name);
+            }
+        };
+        // Mark cells stale when their dependent database tables change (schema-level).
+        store.subscribe((state, prevState) => {
+            if (state.db.tables === prevState.db.tables)
+                return;
+            const toName = (t) => `${t.table.schema ?? 'main'}.${t.table.table}`;
+            const oldNames = new Set(prevState.db.tables.map(toName));
+            const newNames = new Set(state.db.tables.map(toName));
+            const changed = new Set();
+            for (const n of oldNames) {
+                if (!newNames.has(n))
+                    changed.add(n);
+            }
+            for (const n of newNames) {
+                if (!oldNames.has(n))
+                    changed.add(n);
+            }
+            if (!changed.size)
+                return;
+            for (const sheet of Object.values(state.cells.config.sheets)) {
+                const cache = sheet.graphCache;
+                if (!cache?.tableDependencies)
+                    continue;
+                for (const [cellId, tables] of Object.entries(cache.tableDependencies)) {
+                    if (tables.some((t) => changed.has(t))) {
+                        state.cells.invalidateCellStatus(cellId);
+                    }
+                }
+            }
+        });
         return {
             cells: {
                 cellRegistry,
@@ -69,6 +109,42 @@ export function createCellsSlice(props) {
                 activeAbortControllers: {},
                 resultVersion: {},
                 pageVersion: {},
+                async initialize() {
+                    for (const [cellId, cell] of Object.entries(get().cells.config.data)) {
+                        const registryItem = cellRegistry[cell.type];
+                        if (registryItem?.onInitialize) {
+                            registryItem.onInitialize({
+                                id: cellId,
+                                status: get().cells.status[cellId],
+                                get,
+                                set,
+                            });
+                        }
+                    }
+                },
+                crossFilterSelections: {},
+                setCrossFilterSelection: (chartCellId, sqlId, selection) => {
+                    set((state) => produce(state, (draft) => {
+                        if (!draft.cells.crossFilterSelections[sqlId]) {
+                            draft.cells.crossFilterSelections[sqlId] = {};
+                        }
+                        draft.cells.crossFilterSelections[sqlId][chartCellId] = selection;
+                    }));
+                },
+                getCrossFilterPredicate: (chartCellId, sqlId) => {
+                    const group = get().cells.crossFilterSelections[sqlId];
+                    if (!group)
+                        return null;
+                    const siblingSelections = Object.entries(group)
+                        .filter(([id]) => id !== chartCellId)
+                        .map(([, sel]) => sel);
+                    return buildCrossFilterPredicate(siblingSelections);
+                },
+                clearCrossFilterGroup: (sqlId) => {
+                    set((state) => produce(state, (draft) => {
+                        delete draft.cells.crossFilterSelections[sqlId];
+                    }));
+                },
                 addCell: async (sheetId, cell, index) => {
                     // Pre-compute dependencies outside produce() to support async
                     const sqlSelectToJson = getRequiredSqlSelectToJson(get());
@@ -78,19 +154,20 @@ export function createCellsSlice(props) {
                         .filter(isDefined)
                         .map((candidate) => [candidate.id, candidate]));
                     scopedCells[cell.id] = cell;
+                    // Generate a unique result name for SQL cells if not set
+                    if (cell.type === 'sql' && !cell.data.resultName) {
+                        const existingNames = Object.values(scopedCells)
+                            .filter((c) => c.type === 'sql' && c.id !== cell.id)
+                            .map((c) => getEffectiveResultName(c.data, convertToValidColumnOrTableName));
+                        const baseName = getEffectiveResultName(cell.data, convertToValidColumnOrTableName);
+                        const uniqueName = generateUniqueName(baseName, existingNames);
+                        cell.data.resultName = uniqueName;
+                    }
                     const deps = await resolveDependencies(cell, scopedCells, sheetId, cellRegistry, sqlSelectToJson);
                     set((state) => produce(state, (draft) => {
                         draft.cells.config.data[cell.id] = cell;
-                        if (cell.type === 'sql') {
-                            draft.cells.status[cell.id] = {
-                                type: 'sql',
-                                status: 'idle',
-                                referencedTables: [],
-                            };
-                        }
-                        else {
-                            draft.cells.status[cell.id] = { type: 'other' };
-                        }
+                        const registryItem = cellRegistry[cell.type];
+                        draft.cells.status[cell.id] = registryItem?.createStatus?.(cell.id) ?? { type: 'other' };
                         // Single-owner invariant: a cell can belong to one sheet only.
                         for (const [existingSheetId, existingSheet] of Object.entries(draft.cells.config.sheets)) {
                             if (existingSheetId === sheetId)
@@ -112,6 +189,7 @@ export function createCellsSlice(props) {
                                     dependencies: {},
                                     dependents: {},
                                     contentHashByCell: {},
+                                    tableDependencies: {},
                                 },
                             };
                             draft.cells.config.sheets[sheetId] = sheet;
@@ -129,7 +207,7 @@ export function createCellsSlice(props) {
                         sheet.edges = sheet.edges.filter((edge) => edge.target !== cell.id &&
                             edge.id !== `${edge.source}-${cell.id}`);
                         const localCellIds = new Set(sheet.cellIds);
-                        for (const depId of deps) {
+                        for (const depId of deps.cellIds) {
                             if (!localCellIds.has(depId) || depId === cell.id)
                                 continue;
                             sheet.edges.push({
@@ -138,10 +216,11 @@ export function createCellsSlice(props) {
                                 target: cell.id,
                             });
                         }
-                        replaceCellDependenciesInCache(sheet, cell.id, deps.filter((depId) => localCellIds.has(depId)));
+                        replaceCellDependenciesInCache(sheet, cell.id, deps.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
                     }));
                 },
                 removeCell: (id) => {
+                    const cell = get().cells.config.data[id];
                     const previousStatus = get().cells.status[id];
                     cellResultCache.delete(id);
                     set((state) => produce(state, (draft) => {
@@ -161,8 +240,19 @@ export function createCellsSlice(props) {
                             removeCellFromCache(sheet, id);
                         }
                     }));
-                    if (previousStatus?.type === 'sql') {
-                        void dropSqlResultRelation(previousStatus.resultView);
+                    if (cell) {
+                        const registryItem = cellRegistry[cell.type];
+                        if (registryItem?.onRemove) {
+                            void registryItem.onRemove({
+                                id,
+                                status: previousStatus,
+                                get,
+                                set,
+                            });
+                        }
+                        else {
+                            void dropRelationsForStatus(cell.type, previousStatus);
+                        }
                     }
                 },
                 updateCell: async (id, updater, opts) => {
@@ -178,15 +268,11 @@ export function createCellsSlice(props) {
                         .map((candidate) => [candidate.id, candidate]));
                     const updatedCell = updater(cell);
                     scopedCells[id] = updatedCell;
-                    // Check if resultName changed for SQL cells with successful execution
-                    const resultNameChanged = isSqlCell(cell) &&
-                        isSqlCell(updatedCell) &&
-                        cell.data.resultName !== updatedCell.data.resultName;
+                    const registryItem = cellRegistry[cell.type];
                     const existingStatus = get().cells.status[id];
-                    const hasExistingView = resultNameChanged &&
-                        existingStatus?.type === 'sql' &&
-                        existingStatus.status === 'success' &&
-                        existingStatus.resultView;
+                    const oldResultRelation = existingStatus && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(existingStatus)
+                        : undefined;
                     const semanticInputChanged = isInputCell(cell) &&
                         isInputCell(updatedCell) &&
                         (cell.data.input.varName !== updatedCell.data.input.varName ||
@@ -194,12 +280,20 @@ export function createCellsSlice(props) {
                     const semanticSqlChanged = isSqlCell(cell) &&
                         isSqlCell(updatedCell) &&
                         cell.data.sql !== updatedCell.data.sql;
+                    const semanticChanged = registryItem?.hasSemanticChange?.(cell, updatedCell) ?? false;
                     // Apply cell data to the store immediately so that other
                     // actions (e.g. runCell triggered via Cmd+Enter) always see
                     // the latest value. Edge/dependency updates follow
                     // asynchronously below.
                     set((state) => produce(state, (draft) => {
                         draft.cells.config.data[id] = updatedCell;
+                        if (semanticChanged) {
+                            const status = draft.cells.status[id];
+                            if (status && registryItem?.invalidateStatus) {
+                                draft.cells.status[id] =
+                                    registryItem.invalidateStatus(status);
+                            }
+                        }
                     }));
                     // Avoid expensive dependency graph recomputation on each SQL keystroke.
                     // We recompute immediately for non-SQL edits, or when callers explicitly
@@ -214,7 +308,7 @@ export function createCellsSlice(props) {
                             if (ownerSheet) {
                                 const localCellIds = new Set(ownerSheet.cellIds);
                                 ownerSheet.edges = ownerSheet.edges.filter((e) => e.target !== id);
-                                for (const depId of newDeps) {
+                                for (const depId of newDeps.cellIds) {
                                     if (!localCellIds.has(depId) || depId === id)
                                         continue;
                                     ownerSheet.edges.push({
@@ -223,25 +317,27 @@ export function createCellsSlice(props) {
                                         target: id,
                                     });
                                 }
-                                replaceCellDependenciesInCache(ownerSheet, id, newDeps.filter((depId) => localCellIds.has(depId)));
+                                replaceCellDependenciesInCache(ownerSheet, id, newDeps.cellIds.filter((depId) => localCellIds.has(depId)), newDeps.tableNames);
                             }
                         }));
                     }
-                    // If we have an existing view, rename it instead of invalidating
-                    if (hasExistingView && existingStatus?.resultView) {
-                        const registryItem = cellRegistry[cell.type];
-                        if (registryItem?.renameResult) {
-                            void registryItem.renameResult({
-                                id,
-                                oldResultView: existingStatus.resultView,
-                                get,
-                                set,
-                            });
-                        }
+                    // If the result relation changed name (e.g. SQL resultName changed), rename it
+                    const newStatus = get().cells.status[id];
+                    const newResultRelation = newStatus && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(newStatus)
+                        : undefined;
+                    const resultRelationChanged = oldResultRelation && newResultRelation !== oldResultRelation;
+                    if (resultRelationChanged && registryItem?.renameResult) {
+                        void registryItem.renameResult({
+                            id,
+                            oldResultView: oldResultRelation,
+                            get,
+                            set,
+                        });
                     }
                     // After update, trigger cascade only if explicitly requested
                     // or if semantic execution inputs changed.
-                    const shouldCascade = opts?.cascade || resultNameChanged || semanticInputChanged;
+                    const shouldCascade = opts?.cascade || resultRelationChanged || semanticInputChanged;
                     if (shouldCascade) {
                         if (ownerSheetId) {
                             void get().cells.runDownstreamCascade(ownerSheetId, id);
@@ -265,6 +361,7 @@ export function createCellsSlice(props) {
                                 dependencies: {},
                                 dependents: {},
                                 contentHashByCell: {},
+                                tableDependencies: {},
                             },
                         };
                         draft.cells.config.sheetOrder.push(id);
@@ -278,10 +375,12 @@ export function createCellsSlice(props) {
                         return;
                     const ownedCellIds = [...sheet.cellIds];
                     const relationNamesToDrop = ownedCellIds.flatMap((cellId) => {
+                        const cell = get().cells.config.data[cellId];
                         const status = get().cells.status[cellId];
-                        return status?.type === 'sql' && status.resultView
-                            ? [status.resultView]
-                            : [];
+                        if (!cell || !status)
+                            return [];
+                        const registryItem = cellRegistry[cell.type];
+                        return registryItem?.getRelationsToDrop?.(status) ?? [];
                     });
                     set((state) => produce(state, (draft) => {
                         for (const cellId of ownedCellIds) {
@@ -313,7 +412,7 @@ export function createCellsSlice(props) {
                         }
                     }));
                     for (const relationName of relationNamesToDrop) {
-                        void dropSqlResultRelation(relationName);
+                        void dropRelationBestEffort(relationName);
                     }
                 },
                 closeSheet: (sheetId) => {
@@ -369,6 +468,7 @@ export function createCellsSlice(props) {
                                     dependencies: {},
                                     dependents: {},
                                     contentHashByCell: {},
+                                    tableDependencies: {},
                                 },
                             };
                             draft.cells.config.sheets[sheetId] = sheet;
@@ -421,7 +521,7 @@ export function createCellsSlice(props) {
                         if (draftSheet) {
                             draftSheet.edges = draftSheet.edges.filter((e) => e.target !== cellId);
                             const localCellIds = new Set(draftSheet.cellIds);
-                            for (const depId of deps) {
+                            for (const depId of deps.cellIds) {
                                 if (!localCellIds.has(depId) || depId === cellId)
                                     continue;
                                 draftSheet.edges.push({
@@ -430,7 +530,7 @@ export function createCellsSlice(props) {
                                     target: cellId,
                                 });
                             }
-                            replaceCellDependenciesInCache(draftSheet, cellId, deps.filter((depId) => localCellIds.has(depId)));
+                            replaceCellDependenciesInCache(draftSheet, cellId, deps.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
                         }
                     }));
                 },
@@ -457,15 +557,14 @@ export function createCellsSlice(props) {
                     }
                 },
                 invalidateCellStatus: (id) => {
+                    const cell = get().cells.config.data[id];
+                    if (!cell)
+                        return;
+                    const registryItem = cellRegistry[cell.type];
                     set((state) => produce(state, (draft) => {
                         const status = draft.cells.status[id];
-                        if (status?.type === 'sql') {
-                            // Reset to idle, clearing the result so user knows to re-run
-                            draft.cells.status[id] = {
-                                type: 'sql',
-                                status: 'idle',
-                                referencedTables: status.referencedTables || [],
-                            };
+                        if (status && registryItem?.invalidateStatus) {
+                            draft.cells.status[id] = registryItem.invalidateStatus(status);
                         }
                     }));
                 },
@@ -496,14 +595,21 @@ export function createCellsSlice(props) {
                 },
                 fetchCellResultPage: async (id, pagination, sorting) => {
                     const state = get();
+                    const cell = state.cells.config.data[id];
+                    if (!cell)
+                        return;
+                    const registryItem = cellRegistry[cell.type];
                     const status = state.cells.status[id];
-                    if (status?.type !== 'sql' || !status.resultView)
+                    const resultRelation = status && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(status)
+                        : undefined;
+                    if (!resultRelation)
                         return;
                     const connector = await state.db.getConnector();
-                    const baseQuery = sanitizeQuery(`SELECT * FROM ${status.resultView}`);
+                    const baseQuery = sanitizeQuery(`SELECT * FROM ${resultRelation}`);
                     const pagedQuery = makePagedQuery(baseQuery, sorting ?? [], pagination);
                     const arrowTable = await connector.query(pagedQuery);
-                    const countResult = await connector.query(`SELECT COUNT(*)::int AS count FROM ${status.resultView}`);
+                    const countResult = await connector.query(`SELECT COUNT(*)::int AS count FROM ${resultRelation}`);
                     const totalRows = countResult.toArray()[0]?.count ?? 0;
                     get().cells.setCellResultPage(id, { arrowTable, totalRows });
                 },
@@ -547,13 +653,19 @@ export function createCellsSlice(props) {
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
-                            set((state) => produce(state, (draft) => {
-                                const status = draft.cells.status[cellId];
-                                if (status?.type === 'sql') {
-                                    status.status = 'error';
-                                    status.lastError = message;
-                                }
-                            }));
+                            const failedCell = get().cells.config.data[cellId];
+                            const failedRegistryItem = failedCell
+                                ? cellRegistry[failedCell.type]
+                                : undefined;
+                            if (failedRegistryItem?.recordError) {
+                                set((state) => produce(state, (draft) => {
+                                    const status = draft.cells.status[cellId];
+                                    if (status) {
+                                        draft.cells.status[cellId] =
+                                            failedRegistryItem.recordError(status, message);
+                                    }
+                                }));
+                            }
                         }
                     }
                 },
@@ -585,13 +697,19 @@ export function createCellsSlice(props) {
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
-                            set((state) => produce(state, (draft) => {
-                                const status = draft.cells.status[cellId];
-                                if (status?.type === 'sql') {
-                                    status.status = 'error';
-                                    status.lastError = message;
-                                }
-                            }));
+                            const failedCell = get().cells.config.data[cellId];
+                            const failedRegistryItem = failedCell
+                                ? cellRegistry[failedCell.type]
+                                : undefined;
+                            if (failedRegistryItem?.recordError) {
+                                set((state) => produce(state, (draft) => {
+                                    const status = draft.cells.status[cellId];
+                                    if (status) {
+                                        draft.cells.status[cellId] =
+                                            failedRegistryItem.recordError(status, message);
+                                    }
+                                }));
+                            }
                         }
                     }
                 },