sqlite-hub 0.12.0 → 0.17.0

package/frontend/js/utils/tableDesigner.js

@@ -103,6 +103,52 @@ function normalizeDraft(rawDraft = {}) {
     columns: Array.isArray(rawDraft.columns)
       ? rawDraft.columns.map((column) => createEmptyTableDesignerColumn(column))
       : [],
+    uniqueConstraints: Array.isArray(rawDraft.uniqueConstraints)
+      ? rawDraft.uniqueConstraints.map((constraint, index) => ({
+          id: normalizeText(constraint.id ?? `unique:${index}`),
+          name: normalizeText(constraint.name ?? ""),
+          originalName: normalizeText(constraint.originalName ?? constraint.name ?? ""),
+          columns: Array.isArray(constraint.columns)
+            ? constraint.columns
+                .map((column) => ({
+                  name: normalizeText(column?.name ?? ""),
+                  descending: normalizeBoolean(column?.descending),
+                  collation: normalizeText(column?.collation ?? ""),
+                }))
+                .filter((column) => normalizeTrimmed(column.name))
+            : [],
+          partial: normalizeBoolean(constraint.partial),
+          origin: normalizeText(constraint.origin ?? ""),
+          sql: normalizeText(constraint.sql ?? ""),
+          originalSql: normalizeText(constraint.originalSql ?? constraint.sql ?? ""),
+          expression: normalizeText(constraint.expression ?? ""),
+          originalExpression: normalizeText(constraint.originalExpression ?? constraint.expression ?? constraint.sql ?? ""),
+          editable: normalizeBoolean(constraint.editable),
+          preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+        }))
+      : [],
+    checkConstraints: Array.isArray(rawDraft.checkConstraints)
+      ? rawDraft.checkConstraints.map((constraint, index) => ({
+          id: normalizeText(constraint.id ?? `check:${index}`),
+          name: normalizeText(constraint.name ?? `CHECK ${index + 1}`),
+          originalName: normalizeText(constraint.originalName ?? constraint.name ?? `CHECK ${index + 1}`),
+          columns: Array.isArray(constraint.columns)
+            ? constraint.columns
+                .map((column) => ({
+                  name: normalizeText(column?.name ?? ""),
+                  allowedValues: Array.isArray(column?.allowedValues)
+                    ? column.allowedValues.map((value) => normalizeText(value))
+                    : [],
+                }))
+                .filter((column) => normalizeTrimmed(column.name))
+            : [],
+          expression: normalizeText(constraint.expression ?? ""),
+          originalExpression: normalizeText(constraint.originalExpression ?? constraint.expression ?? ""),
+          editable: normalizeBoolean(constraint.editable),
+          preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+        }))
+      : [],
+    designerVersion: Number(rawDraft.designerVersion) || 1,
     schemaWarnings: Array.isArray(rawDraft.schemaWarnings) ? rawDraft.schemaWarnings : [],
     fillImportedRows: normalizeBoolean(rawDraft.fillImportedRows),
     importedCsvFileName: normalizeText(rawDraft.importedCsvFileName ?? ""),
@@ -164,7 +210,7 @@ function validatePrimaryKeys(draft) {
   }
 
   if (draft.mode !== "edit") {
-    return ["Table Designer v1 supports only one primary key column for new tables."];
+    return ["Table Designer v2 supports only one primary key column for new tables."];
   }
 
   const originalPrimaryKeyNames = new Set(
@@ -185,7 +231,7 @@ function validatePrimaryKeys(draft) {
 
   return isUnchangedCompositePrimaryKey
     ? []
-    : ["Composite primary keys can be preserved but not edited in Table Designer v1."];
+    : ["Composite primary keys can be preserved but not edited in Table Designer v2."];
 }
 
 function resolveReferencedTableColumns(draft, catalogTables, referencedTableName) {
@@ -330,6 +376,17 @@ function hasColumnChanged(originalColumn, draftColumn) {
   );
 }
 
+function hasConstraintChanged(constraint) {
+  return (
+    normalizeComparableValue(constraint.name) !==
+      normalizeComparableValue(constraint.originalName ?? constraint.name) ||
+    normalizeComparableValue(constraint.expression || constraint.sql) !==
+      normalizeComparableValue(
+        constraint.originalExpression ?? constraint.originalSql ?? constraint.expression ?? constraint.sql
+      )
+  );
+}
+
 function buildColumnDefinition(column) {
   const parts = [quoteIdentifier(column.name)];
   const type = normalizeComparableValue(column.type);
@@ -373,6 +430,24 @@ function buildCreateTableSql(draft) {
   return `CREATE TABLE ${quoteIdentifier(draft.tableName)} (\n${columnSql}\n);`;
 }
 
+function getUniqueConstraintExpression(constraint) {
+  const expression = normalizeTrimmed(constraint.expression || constraint.sql);
+
+  if (expression) {
+    return expression;
+  }
+
+  const columnSql = (constraint.columns ?? [])
+    .map((column) => quoteIdentifier(column.name))
+    .join(", ");
+
+  return columnSql ? `UNIQUE (${columnSql})` : "UNIQUE constraint";
+}
+
+function getCheckConstraintExpression(constraint) {
+  return normalizeTrimmed(constraint.expression) || "CHECK constraint";
+}
+
 function buildAlterTableRenameSql(fromName, toName) {
   return `ALTER TABLE ${quoteIdentifier(fromName)} RENAME TO ${quoteIdentifier(toName)};`;
 }
@@ -484,7 +559,7 @@ function analyzeEditDraft(draft) {
           warnings.push(
             buildRiskyChangeWarning(
               "Column Rename Requires Rebuild",
-              `Renaming column ${originalColumn.name} to ${column.name} is intentionally blocked in Table Designer v1.`
+              `Renaming column ${originalColumn.name} to ${column.name} is intentionally blocked in Table Designer v2.`
             )
           );
         }
@@ -580,6 +655,19 @@ function analyzeEditDraft(draft) {
     );
   });
 
+  [...(draft.uniqueConstraints ?? []), ...(draft.checkConstraints ?? [])].forEach((constraint) => {
+    if (!hasConstraintChanged(constraint)) {
+      return;
+    }
+
+    warnings.push(
+      buildRiskyChangeWarning(
+        "Constraint Change Requires Rebuild",
+        `Changing ${constraint.originalName || constraint.name || "a table constraint"} requires a SQLite table rebuild.`
+      )
+    );
+  });
+
   return {
     dirty: Boolean(executableStatements.length || warnings.length),
     executable: warnings.length === 0,
@@ -611,10 +699,43 @@ function prefixSqlAsComment(sql) {
 }
 
 function buildPreviewSql({ draft, validationErrors, warnings, analysis, readOnly }) {
+  const preservedUniqueConstraints = draft.mode === "edit" ? draft.uniqueConstraints ?? [] : [];
+  const preservedCheckConstraints = draft.mode === "edit" ? draft.checkConstraints ?? [] : [];
+  const preservedUniqueConstraintComments = preservedUniqueConstraints.length
+    ? [
+        "-- Table Designer v2 preserves these UNIQUE constraints:",
+        ...preservedUniqueConstraints.map(
+          (constraint) => `-- - ${getUniqueConstraintExpression(constraint)}`
+        ),
+      ]
+    : [];
+  const preservedCheckConstraintComments = preservedCheckConstraints.length
+    ? [
+        "-- Table Designer v2 preserves these CHECK constraints:",
+        ...preservedCheckConstraints.map(
+          (constraint) => `-- - ${getCheckConstraintExpression(constraint)}`
+        ),
+      ]
+    : [];
+  const preservedConstraintComments = [
+    ...preservedUniqueConstraintComments,
+    ...(
+      preservedUniqueConstraintComments.length && preservedCheckConstraintComments.length
+        ? [""]
+        : []
+    ),
+    ...preservedCheckConstraintComments,
+  ];
+
   if (readOnly) {
     return [
       "-- This connection is opened READ ONLY.",
       "-- Table Designer preview is available, but schema changes cannot be saved.",
+      ...(
+        preservedConstraintComments.length
+          ? ["", ...preservedConstraintComments]
+          : []
+      ),
     ].join("\n");
   }
 
@@ -627,7 +748,7 @@ function buildPreviewSql({ draft, validationErrors, warnings, analysis, readOnly
 
   if (warnings.some((warning) => warning.blocking)) {
     const lines = [
-      "-- This draft is not executable in Table Designer v1.",
+      "-- This draft is not executable in Table Designer v2.",
       "-- SQLite would require a table rebuild for the requested changes:",
       ...warnings
         .filter((warning) => warning.blocking)
@@ -641,6 +762,10 @@ function buildPreviewSql({ draft, validationErrors, warnings, analysis, readOnly
       });
     }
 
+    if (preservedConstraintComments.length) {
+      lines.push("", ...preservedConstraintComments);
+    }
+
     lines.push(
       "",
       "-- Suggested rebuild outline:",
@@ -656,10 +781,25 @@ function buildPreviewSql({ draft, validationErrors, warnings, analysis, readOnly
   }
 
   if (!analysis.dirty && draft.mode === "edit") {
-    return "-- No schema changes pending.";
+    return [
+      "-- No schema changes pending.",
+      ...(
+        preservedConstraintComments.length
+          ? ["", ...preservedConstraintComments]
+          : []
+      ),
+    ].join("\n");
   }
 
-  return [...analysis.statements, ...buildImportedInsertPreviewSql(draft)].join("\n\n");
+  return [
+    ...analysis.statements,
+    ...(
+      preservedConstraintComments.length
+        ? [preservedConstraintComments.join("\n")]
+        : []
+    ),
+    ...buildImportedInsertPreviewSql(draft),
+  ].join("\n\n");
 }
 
 function escapeSqlLiteral(value) {
@@ -1029,6 +1169,9 @@ export function createTableDesignerDraftFromCsvImport(
       originalTableName: "",
       tableName: suggestImportedTableName(fileName, catalogTables),
       columns,
+      uniqueConstraints: [],
+      checkConstraints: [],
+      designerVersion: 2,
       schemaWarnings: [],
       fillImportedRows: importedCsvRows.length > 0,
       importedCsvFileName: normalizeText(fileName),
@@ -1053,6 +1196,9 @@ export function createNewTableDesignerDraft() {
     originalTableName: "",
     tableName: "",
     columns: [createEmptyTableDesignerColumn()],
+    uniqueConstraints: [],
+    checkConstraints: [],
+    designerVersion: 2,
     dirty: false,
     schemaWarnings: [],
     fillImportedRows: false,
@@ -1151,6 +1297,32 @@ export function updateTableDesignerColumnField(draft, columnId, field, value, co
   );
 }
 
+export function updateTableDesignerConstraintField(
+  draft,
+  constraintKind,
+  constraintId,
+  field,
+  value,
+  context = {}
+) {
+  const collectionKey = constraintKind === "check" ? "checkConstraints" : "uniqueConstraints";
+
+  return recalculateTableDesignerDraft(
+    {
+      ...draft,
+      [collectionKey]: (draft[collectionKey] ?? []).map((constraint) =>
+        constraint.id === constraintId
+          ? {
+              ...constraint,
+              [field]: value,
+            }
+          : constraint
+      ),
+    },
+    context
+  );
+}
+
 export function addTableDesignerColumn(draft, context = {}) {
   return recalculateTableDesignerDraft(
     {

package/frontend/js/utils/textCellStats.js

@@ -0,0 +1,20 @@
+const CHARACTER_COUNT_FORMATTER = new Intl.NumberFormat("en-US");
+
+export function getTextCellCharacterCount(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+
+  return Array.from(value).length;
+}
+
+export function formatTextCellCharacterCount(count) {
+  const numericCount = Number(count);
+
+  if (!Number.isFinite(numericCount) || numericCount < 0) {
+    return "";
+  }
+
+  const label = numericCount === 1 ? "char" : "chars";
+  return `${CHARACTER_COUNT_FORMATTER.format(numericCount)} ${label}`;
+}

package/frontend/js/utils/timestampPreview.js

@@ -0,0 +1,264 @@
+const MIN_TIMESTAMP_YEAR = 1990;
+const MAX_TIMESTAMP_YEAR = 2100;
+const MIN_TIMESTAMP_MS = Date.UTC(MIN_TIMESTAMP_YEAR, 0, 1, 0, 0, 0);
+const MAX_TIMESTAMP_MS = Date.UTC(MAX_TIMESTAMP_YEAR, 11, 31, 23, 59, 59, 999);
+const MIN_UNIX_SECONDS = Math.floor(MIN_TIMESTAMP_MS / 1000);
+const MAX_UNIX_SECONDS = Math.floor(MAX_TIMESTAMP_MS / 1000);
+const MIN_UNIX_MILLISECONDS = MIN_TIMESTAMP_MS;
+const MAX_UNIX_MILLISECONDS = MAX_TIMESTAMP_MS;
+const MIN_UNIX_MICROSECONDS = MIN_TIMESTAMP_MS * 1000;
+const MAX_UNIX_MICROSECONDS = MAX_TIMESTAMP_MS * 1000;
+
+function normalizeColumnName(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+
+function getColumnMeta(columnName, tableMeta = {}) {
+  const normalizedColumnName = normalizeColumnName(columnName);
+
+  return (tableMeta.columns ?? tableMeta.columnMeta ?? []).find(
+    (column) => normalizeColumnName(column?.name) === normalizedColumnName
+  );
+}
+
+function getForeignKeyColumnNames(tableMeta = {}) {
+  const names = new Set();
+
+  for (const foreignKey of tableMeta.foreignKeys ?? []) {
+    for (const mapping of foreignKey?.mappings ?? []) {
+      const from = normalizeColumnName(mapping?.from);
+
+      if (from) {
+        names.add(from);
+      }
+    }
+  }
+
+  return names;
+}
+
+export function isProtectedKeyColumn(columnName, tableMeta = {}) {
+  const normalizedColumnName = normalizeColumnName(columnName);
+
+  if (!normalizedColumnName) {
+    return false;
+  }
+
+  const column = getColumnMeta(columnName, tableMeta);
+
+  if (Number(column?.primaryKeyPosition ?? 0) > 0 || column?.primaryKey === true) {
+    return true;
+  }
+
+  if (column?.foreignKey === true) {
+    return true;
+  }
+
+  return getForeignKeyColumnNames(tableMeta).has(normalizedColumnName);
+}
+
+export function isIdLikeColumnName(columnName) {
+  const normalizedColumnName = normalizeColumnName(columnName);
+
+  if (!normalizedColumnName) {
+    return false;
+  }
+
+  return (
+    normalizedColumnName === "id" ||
+    normalizedColumnName === "rowid" ||
+    normalizedColumnName === "_id" ||
+    normalizedColumnName.endsWith("_id") ||
+    normalizedColumnName.endsWith(" id") ||
+    normalizedColumnName.includes("uuid") ||
+    normalizedColumnName.endsWith("_uuid") ||
+    normalizedColumnName.endsWith("_key")
+  );
+}
+
+function isPlausibleTimestampDate(date) {
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+    return false;
+  }
+
+  const time = date.getTime();
+  const year = date.getFullYear();
+
+  return (
+    time >= MIN_TIMESTAMP_MS &&
+    time <= MAX_TIMESTAMP_MS &&
+    year >= MIN_TIMESTAMP_YEAR &&
+    year <= MAX_TIMESTAMP_YEAR
+  );
+}
+
+function normalizeNumericTimestamp(value) {
+  const text = String(value ?? "").trim();
+
+  if (!/^\d+$/.test(text)) {
+    return null;
+  }
+
+  const numericValue = Number(text);
+
+  if (!Number.isSafeInteger(numericValue)) {
+    return null;
+  }
+
+  if (numericValue >= MIN_UNIX_MICROSECONDS && numericValue <= MAX_UNIX_MICROSECONDS) {
+    return {
+      date: new Date(Math.floor(numericValue / 1000)),
+      sourceFormat: "unix-microseconds",
+    };
+  }
+
+  if (numericValue >= MIN_UNIX_MILLISECONDS && numericValue <= MAX_UNIX_MILLISECONDS) {
+    return {
+      date: new Date(numericValue),
+      sourceFormat: "unix-milliseconds",
+    };
+  }
+
+  if (numericValue >= MIN_UNIX_SECONDS && numericValue <= MAX_UNIX_SECONDS) {
+    return {
+      date: new Date(numericValue * 1000),
+      sourceFormat: "unix-seconds",
+    };
+  }
+
+  return null;
+}
+
+function normalizeSqliteDateTimeString(value) {
+  const text = String(value ?? "").trim();
+  const match = text.match(
+    /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/
+  );
+
+  if (!match) {
+    return null;
+  }
+
+  const [, year, month, day, hour, minute, second = "0", millisecond = "0"] = match;
+  const date = new Date(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millisecond.padEnd(3, "0"))
+  );
+
+  return {
+    date,
+    sourceFormat: "sqlite-datetime",
+  };
+}
+
+function normalizeIsoDateTimeString(value) {
+  const text = String(value ?? "").trim();
+
+  if (!/^\d{4}-\d{2}-\d{2}T/.test(text)) {
+    return null;
+  }
+
+  const date = new Date(text);
+
+  return {
+    date,
+    sourceFormat: "iso-datetime",
+  };
+}
+
+export function parseTimestampValue(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  const numericTimestamp = normalizeNumericTimestamp(value);
+
+  if (numericTimestamp && isPlausibleTimestampDate(numericTimestamp.date)) {
+    return numericTimestamp;
+  }
+
+  const isoTimestamp = normalizeIsoDateTimeString(value);
+
+  if (isoTimestamp && isPlausibleTimestampDate(isoTimestamp.date)) {
+    return isoTimestamp;
+  }
+
+  const sqliteTimestamp = normalizeSqliteDateTimeString(value);
+
+  if (sqliteTimestamp && isPlausibleTimestampDate(sqliteTimestamp.date)) {
+    return sqliteTimestamp;
+  }
+
+  return null;
+}
+
+function padDatePart(value) {
+  return String(value).padStart(2, "0");
+}
+
+export function formatTimestampPreview(date) {
+  if (!isPlausibleTimestampDate(date)) {
+    return "";
+  }
+
+  return [
+    padDatePart(date.getDate()),
+    ".",
+    padDatePart(date.getMonth() + 1),
+    ".",
+    date.getFullYear(),
+    ", ",
+    padDatePart(date.getHours()),
+    ":",
+    padDatePart(date.getMinutes()),
+    ":",
+    padDatePart(date.getSeconds()),
+  ].join("");
+}
+
+export function getTimestampPreviewForField({ columnName, value, tableMeta = {} } = {}) {
+  if (isProtectedKeyColumn(columnName, tableMeta)) {
+    return {
+      kind: "protected-key",
+      protected: true,
+      date: null,
+      formatted: "",
+      sourceFormat: "",
+    };
+  }
+
+  if (isIdLikeColumnName(columnName)) {
+    return {
+      kind: "none",
+      protected: false,
+      date: null,
+      formatted: "",
+      sourceFormat: "",
+    };
+  }
+
+  const parsed = parseTimestampValue(value);
+
+  if (!parsed) {
+    return {
+      kind: "none",
+      protected: false,
+      date: null,
+      formatted: "",
+      sourceFormat: "",
+    };
+  }
+
+  return {
+    kind: "timestamp",
+    protected: false,
+    date: parsed.date,
+    formatted: formatTimestampPreview(parsed.date),
+    sourceFormat: parsed.sourceFormat,
+  };
+}

package/frontend/js/views/charts.js

@@ -284,6 +284,8 @@ function renderQueryResultsSection(state) {
                   editable: false,
                   sortColumn: null,
                   sortDirection: null,
+                  resultScope: 'charts',
+                  sortAction: null,
               })}
             </div>
           `
@@ -458,7 +460,7 @@ export function renderChartsDetail(state) {
                 type="button"
               >
                 <span class="material-symbols-outlined text-sm">${
-                  historyVisible ? 'visibility_off' : 'history'
+                  historyVisible ? 'visibility_off' : 'visibility'
                 }</span>
                 ${historyVisible ? 'Hide Query History' : 'Show Query History'}
               </button>

package/frontend/js/views/data.js

@@ -1,6 +1,7 @@
 import { renderDataGrid } from '../components/dataGrid.js';
 import { renderRowEditorPanel } from '../components/rowEditorPanel.js';
 import { escapeHtml, formatCellValue, formatNumber, isBlobPreview, truncateMiddle } from '../utils/format.js';
+import { compactPathForDisplay, detectFilePathValue } from '../utils/filePathPreview.js';
 
 function getSelectedRow(state) {
     if (state.dataBrowser.selectedRow) {
@@ -138,7 +139,11 @@ function renderWorkspaceHeader(state) {
                     data-action="toggle-data-tables"
                     type="button"
                   >
-                    ${tablesVisible ? '<span class="material-symbols-outlined text-sm">visibility_off</span> Hide Tables' : 'Show Tables'}
+                    ${
+                        tablesVisible
+                            ? '<span class="material-symbols-outlined text-sm">visibility_off</span> Hide Tables'
+                            : '<span class="material-symbols-outlined text-sm">visibility</span> Show Tables'
+                    }
                   </button>
                   <button
                     class="standard-button"
@@ -362,15 +367,36 @@ function renderTableSurface(state) {
     }));
     const sortColumn = state.dataBrowser.sortColumn;
     const sortDirection = state.dataBrowser.sortDirection;
+    const tableMeta = {
+        columns: table.columnMeta ?? [],
+        foreignKeys: table.foreignKeys ?? [],
+    };
     const columns = (table.columns ?? []).map(columnName => ({
         headerClassName:
             'border-b border-primary-container/20 px-4 py-3 text-[10px] font-bold tracking-[0.08em] text-primary-container',
         renderHeader: () => renderSortableHeader(columnName, sortColumn, sortDirection, 'sort-data-column'),
         cellClassName: 'px-4 py-2 align-top text-[11px] text-on-surface',
         render: row => {
-            const value = formatCellValue(row[columnName]);
+            const rawValue = row[columnName];
+            const filePath = detectFilePathValue(rawValue, columnName, tableMeta);
+            const value = formatCellValue(rawValue);
             const isNull = value === 'NULL';
             const widthClass = getCellWidthClass(columnName);
+
+            if (filePath) {
+                return `
+                  <span
+                    class="inline-flex ${widthClass} items-center gap-2 overflow-hidden whitespace-nowrap text-on-surface"
+                    title="${escapeHtml(filePath.rawValue)}"
+                  >
+                    <span class="material-symbols-outlined text-sm text-on-surface-variant/55">folder</span>
+                    <span class="min-w-0 overflow-hidden text-ellipsis">${escapeHtml(
+                        compactPathForDisplay(filePath.rawValue, 48),
+                    )}</span>
+                  </span>
+                `;
+            }
+
             const displayValue = isNull ? value : truncateMiddle(value, 48);
 
             return `<span class="block ${widthClass} overflow-hidden text-ellipsis whitespace-nowrap ${
@@ -586,8 +612,13 @@ export function renderDataRowEditorPanel(state) {
                 label: column.name,
                 badges: getColumnBadges(column),
             },
+            rawValue: row[column.name],
             value: formatCellValue(row[column.name]),
         })),
+        tableMeta: {
+            columns: table.columnMeta ?? [],
+            foreignKeys: table.foreignKeys ?? [],
+        },
         saveError: state.dataBrowser.saveError,
         saving: state.dataBrowser.saving,
         deleting: state.dataBrowser.deleting,
@@ -595,6 +626,7 @@ export function renderDataRowEditorPanel(state) {
         deleteRowIndex: isIndexedRow ? rowIndex : null,
         deleteEnabled: Boolean(row.__identity),
         reloadAction: 'reload-data-route',
+        jsonActionsEnabled: true,
     });
 }