sqlite-hub 0.12.0 → 0.16.0

package/server/services/sqlite/tableDesigner/validation.js

@@ -66,6 +66,53 @@ function normalizeColumnPayload(column = {}, index = 0) {
   };
 }
 
+function normalizeUniqueConstraintPayload(constraint = {}, index = 0) {
+  return {
+    id: String(constraint.id ?? `unique:${index}`),
+    name: String(constraint.name ?? "").trim(),
+    originalName: String(constraint.originalName ?? constraint.name ?? "").trim(),
+    columns: Array.isArray(constraint.columns)
+      ? constraint.columns
+          .map((column) => ({
+            name: String(column?.name ?? "").trim(),
+            descending: normalizeBoolean(column?.descending),
+            collation: String(column?.collation ?? "").trim(),
+          }))
+          .filter((column) => column.name)
+      : [],
+    partial: normalizeBoolean(constraint.partial),
+    origin: String(constraint.origin ?? "").trim(),
+    sql: String(constraint.sql ?? "").trim(),
+    originalSql: String(constraint.originalSql ?? constraint.sql ?? "").trim(),
+    expression: String(constraint.expression ?? "").trim(),
+    originalExpression: String(constraint.originalExpression ?? constraint.expression ?? constraint.sql ?? "").trim(),
+    editable: normalizeBoolean(constraint.editable),
+    preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+  };
+}
+
+function normalizeCheckConstraintPayload(constraint = {}, index = 0) {
+  return {
+    id: String(constraint.id ?? `check:${index}`),
+    name: String(constraint.name ?? `CHECK ${index + 1}`).trim(),
+    originalName: String(constraint.originalName ?? constraint.name ?? `CHECK ${index + 1}`).trim(),
+    columns: Array.isArray(constraint.columns)
+      ? constraint.columns
+          .map((column) => ({
+            name: String(column?.name ?? "").trim(),
+            allowedValues: Array.isArray(column?.allowedValues)
+              ? column.allowedValues.map((value) => String(value ?? ""))
+              : [],
+          }))
+          .filter((column) => column.name)
+      : [],
+    expression: String(constraint.expression ?? "").trim(),
+    originalExpression: String(constraint.originalExpression ?? constraint.expression ?? "").trim(),
+    editable: normalizeBoolean(constraint.editable),
+    preserved: constraint.preserved === undefined ? true : normalizeBoolean(constraint.preserved),
+  };
+}
+
 function normalizeDraftPayload(payload = {}) {
   const mode = String(payload.mode ?? "create").trim() === "edit" ? "edit" : "create";
 
@@ -76,6 +123,17 @@ function normalizeDraftPayload(payload = {}) {
     columns: Array.isArray(payload.columns)
       ? payload.columns.map((column, index) => normalizeColumnPayload(column, index))
       : [],
+    uniqueConstraints: Array.isArray(payload.uniqueConstraints)
+      ? payload.uniqueConstraints.map((constraint, index) =>
+          normalizeUniqueConstraintPayload(constraint, index)
+        )
+      : [],
+    checkConstraints: Array.isArray(payload.checkConstraints)
+      ? payload.checkConstraints.map((constraint, index) =>
+          normalizeCheckConstraintPayload(constraint, index)
+        )
+      : [],
+    designerVersion: Number(payload.designerVersion) || 1,
     schemaWarnings: Array.isArray(payload.schemaWarnings) ? payload.schemaWarnings : [],
     warnings: Array.isArray(payload.warnings) ? payload.warnings : [],
     fillImportedRows: normalizeBoolean(payload.fillImportedRows),
@@ -112,7 +170,7 @@ function validatePrimaryKeys(draft, originalDraft) {
 
   if (!originalDraft) {
     throw new ValidationError(
-      "Table Designer v1 supports a single primary key column when creating a table."
+      "Table Designer v2 supports a single primary key column when creating a table."
     );
   }
 
@@ -134,7 +192,7 @@ function validatePrimaryKeys(draft, originalDraft) {
 
   if (!isUnchangedCompositePrimaryKey) {
     throw new ValidationError(
-      "Table Designer v1 does not support editing composite primary keys."
+      "Table Designer v2 does not support editing composite primary keys."
     );
   }
 }

package/server/services/sqlite/tableDesignerService.js

@@ -109,7 +109,7 @@ class TableDesignerService {
 
     if (!analysis.executable) {
       throw new ValidationError(
-        "This schema change set would require a SQLite table rebuild. Table Designer v1 keeps the SQL preview available but will not execute those changes automatically.",
+        "This schema change set would require a SQLite table rebuild. Table Designer v2 keeps the SQL preview available but will not execute those changes automatically.",
         {
           code: "TABLE_DESIGNER_REBUILD_REQUIRED",
           warnings: analysis.warnings,

package/tests/check-constraint-options.test.js

@@ -3,6 +3,7 @@ const assert = require("node:assert/strict");
 const test = require("node:test");
 const { getTableDetail } = require("../server/services/sqlite/introspection");
 const { SqlExecutor } = require("../server/services/sqlite/sqlExecutor");
+const { buildTableDesignerDraft } = require("../server/services/sqlite/tableDesigner/schemaMapping");
 
 test("table detail exposes string options from simple CHECK IN constraints", () => {
   const db = new Database(":memory:");
@@ -34,6 +35,7 @@ test("table detail exposes string options from simple CHECK IN constraints", ()
     `);
 
     const tableDetail = getTableDetail(db, "stream_company_mentions");
+    const designerDraft = buildTableDesignerDraft(tableDetail);
     const mentionTypeColumn = tableDetail.columns.find(
       (column) => column.name === "mention_type"
     );
@@ -70,6 +72,18 @@ test("table detail exposes string options from simple CHECK IN constraints", ()
     );
 
     assert.deepEqual(editableColumn.allowedValues, mentionTypeColumn.allowedValues);
+
+    assert.equal(designerDraft.designerVersion, 2);
+    assert.equal(designerDraft.checkConstraints.length, 1);
+    assert.match(designerDraft.checkConstraints[0].expression, /CHECK/i);
+    assert.equal(designerDraft.checkConstraints[0].originalExpression, designerDraft.checkConstraints[0].expression);
+    assert.equal(designerDraft.checkConstraints[0].editable, true);
+    assert.deepEqual(designerDraft.checkConstraints[0].columns, [
+      {
+        name: "mention_type",
+        allowedValues: mentionTypeColumn.allowedValues,
+      },
+    ]);
   } finally {
     db.close();
   }

package/tests/export-filenames.test.js

@@ -0,0 +1,34 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let exportFilenamesModulePromise = null;
+
+function loadExportFilenamesModule() {
+  if (!exportFilenamesModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/exportFilenames.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    exportFilenamesModulePromise = import(url);
+  }
+
+  return exportFilenamesModulePromise;
+}
+
+test("text export filenames use the selected format extension", async () => {
+  const { buildTextExportFilename } = await loadExportFilenamesModule();
+
+  assert.equal(buildTextExportFilename("query-results.csv", { format: "tsv" }), "query-results.tsv");
+  assert.equal(buildTextExportFilename("white_house_live_streams", { format: "md" }), "white_house_live_streams.md");
+});
+
+test("text export filenames sanitize unsafe names and fallback when empty", async () => {
+  const { buildTextExportFilename } = await loadExportFilenamesModule();
+
+  assert.equal(buildTextExportFilename("", { format: "csv", fallback: "table" }), "table.csv");
+  assert.equal(buildTextExportFilename("../bad:name?.csv", { format: "csv", fallback: "table" }), "bad name.csv");
+});

package/tests/file-path-preview.test.js

@@ -0,0 +1,165 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let filePathPreviewModulePromise = null;
+
+function loadFilePathPreviewModule() {
+  if (!filePathPreviewModulePromise) {
+    const timestampPreviewSource = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/timestampPreview.js"),
+      "utf8"
+    );
+    const timestampPreviewUrl = `data:text/javascript;base64,${Buffer.from(timestampPreviewSource).toString("base64")}`;
+    const filePathPreviewSource = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/filePathPreview.js"),
+      "utf8"
+    ).replace(
+      'import { isProtectedKeyColumn } from "./timestampPreview.js";',
+      `import { isProtectedKeyColumn } from "${timestampPreviewUrl}";`
+    );
+    const filePathPreviewUrl = `data:text/javascript;base64,${Buffer.from(filePathPreviewSource).toString("base64")}`;
+
+    filePathPreviewModulePromise = import(filePathPreviewUrl);
+  }
+
+  return filePathPreviewModulePromise;
+}
+
+function createTableMeta() {
+  return {
+    columns: [
+      { name: "id", primaryKeyPosition: 1 },
+      { name: "parent_id", primaryKeyPosition: 0 },
+      { name: "file_path", primaryKeyPosition: 0 },
+      { name: "filename", primaryKeyPosition: 0 },
+      { name: "note", primaryKeyPosition: 0 },
+    ],
+    foreignKeys: [
+      {
+        mappings: [{ from: "parent_id", to: "id" }],
+      },
+    ],
+  };
+}
+
+test("filepath preview detects supported path styles", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+  const cases = [
+    {
+      value: "/Users/oli/project/file.txt",
+      pathType: "unix",
+      fileName: "file.txt",
+      directory: "/Users/oli/project",
+      extension: "txt",
+    },
+    {
+      value: "/home/oli/data/app.sqlite",
+      pathType: "unix",
+      fileName: "app.sqlite",
+      directory: "/home/oli/data",
+      extension: "sqlite",
+    },
+    {
+      value: "C:\\Users\\Oliver\\Desktop\\file.pdf",
+      pathType: "windows",
+      fileName: "file.pdf",
+      directory: "C:\\Users\\Oliver\\Desktop",
+      extension: "pdf",
+    },
+    {
+      value: "./data/export.csv",
+      pathType: "relative",
+      fileName: "export.csv",
+      directory: "./data",
+      extension: "csv",
+    },
+    {
+      value: "../logs/app.log",
+      pathType: "relative",
+      fileName: "app.log",
+      directory: "../logs",
+      extension: "log",
+    },
+    {
+      value: "~/Documents/report.md",
+      pathType: "home",
+      fileName: "report.md",
+      directory: "~/Documents",
+      extension: "md",
+    },
+    {
+      value: "data/images/avatar.png",
+      pathType: "relative",
+      fileName: "avatar.png",
+      directory: "data/images",
+      extension: "png",
+    },
+  ];
+
+  for (const item of cases) {
+    const preview = detectFilePathValue(item.value, "file_path", tableMeta);
+
+    assert.equal(preview?.type, "filepath");
+    assert.equal(preview.pathType, item.pathType);
+    assert.equal(preview.fileName, item.fileName);
+    assert.equal(preview.directory, item.directory);
+    assert.equal(preview.extension, item.extension);
+    assert.ok(preview.confidence >= 0.7);
+  }
+});
+
+test("filepath preview does not detect URLs, primitive text, JSON, emails, or weak filenames", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+  const rejectedValues = [
+    "https://example.com/file.txt",
+    "http://localhost:3000/test",
+    "mailto:oliver@example.com",
+    "tel:+431234567",
+    "ftp://example.com/file.txt",
+    "oliver@example.com",
+    "1717682400",
+    "true",
+    "false",
+    '{"path":"/tmp/file.txt"}',
+    "hello world",
+    "file",
+    "invoice.pdf",
+  ];
+
+  for (const value of rejectedValues) {
+    assert.equal(detectFilePathValue(value, "note", tableMeta), null);
+  }
+});
+
+test("filepath preview protects primary keys and foreign keys", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(detectFilePathValue("/Users/oli/project/file.txt", "id", tableMeta), null);
+  assert.equal(detectFilePathValue("/Users/oli/project/file.txt", "parent_id", tableMeta), null);
+});
+
+test("filepath preview allows bare filenames only for strong file columns", async () => {
+  const { detectFilePathValue } = await loadFilePathPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(detectFilePathValue("invoice.pdf", "note", tableMeta), null);
+
+  const preview = detectFilePathValue("invoice.pdf", "filename", tableMeta);
+
+  assert.equal(preview?.pathType, "relative");
+  assert.equal(preview.fileName, "invoice.pdf");
+  assert.equal(preview.directory, null);
+  assert.equal(preview.extension, "pdf");
+});
+
+test("filepath preview compacts long paths while preserving filename", async () => {
+  const { compactPathForDisplay } = await loadFilePathPreviewModule();
+  const display = compactPathForDisplay("/Users/oli/projects/sqlite-hub/data/app.sqlite", 24);
+
+  assert.equal(display, ".../data/app.sqlite");
+});

package/tests/row-editor-json.test.js

@@ -0,0 +1,82 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+let rowEditorJsonModulePromise = null;
+
+function loadRowEditorJsonModule() {
+  if (!rowEditorJsonModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/rowEditorJson.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    rowEditorJsonModulePromise = import(url);
+  }
+
+  return rowEditorJsonModulePromise;
+}
+
+test("row editor JSON for data rows preserves column order and omits identity metadata", async () => {
+  const { buildDataRowEditorJsonObject, stringifyRowEditorJson } = await loadRowEditorJsonModule();
+  const row = {
+    id: 1,
+    title: "Event",
+    created_at: 1717682400,
+    payload: { __type: "blob", sizeBytes: 4, hexPreview: "ffff" },
+    __identity: { kind: "primaryKey", values: { id: 1 } },
+  };
+  const rowObject = buildDataRowEditorJsonObject({
+    row,
+    columns: ["id", "title", "created_at", "payload"],
+  });
+
+  assert.deepEqual(Object.keys(rowObject), ["id", "title", "created_at", "payload"]);
+  assert.deepEqual(rowObject, {
+    id: 1,
+    title: "Event",
+    created_at: 1717682400,
+    payload: { __type: "blob", sizeBytes: 4, hexPreview: "ffff" },
+  });
+  assert.equal(
+    stringifyRowEditorJson(rowObject),
+    [
+      "{",
+      '  "id": 1,',
+      '  "title": "Event",',
+      '  "created_at": 1717682400,',
+      '  "payload": {',
+      '    "__type": "blob",',
+      '    "sizeBytes": 4,',
+      '    "hexPreview": "ffff"',
+      "  }",
+      "}",
+    ].join("\n")
+  );
+});
+
+test("row editor JSON for SQL result rows maps visible source columns once", async () => {
+  const { buildEditorRowEditorJsonObject } = await loadRowEditorJsonModule();
+  const rowObject = buildEditorRowEditorJsonObject({
+    row: {
+      id: 1,
+      title_alias: "Event",
+      duplicate_title: "Ignored",
+      hidden_note: "Hidden",
+      __identity: { kind: "primaryKey", values: { id: 1 } },
+    },
+    editingColumns: [
+      { resultName: "id", sourceColumn: "id", visible: true },
+      { resultName: "title_alias", sourceColumn: "title", visible: true },
+      { resultName: "duplicate_title", sourceColumn: "title", visible: true },
+      { resultName: "hidden_note", sourceColumn: "note", visible: false },
+    ],
+  });
+
+  assert.deepEqual(rowObject, {
+    id: 1,
+    title: "Event",
+  });
+});

package/tests/row-editor-timestamp-preview.test.js

@@ -0,0 +1,192 @@
+const Database = require("better-sqlite3");
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+const { DataBrowserService } = require("../server/services/sqlite/dataBrowserService");
+
+let timestampPreviewModulePromise = null;
+
+function loadTimestampPreviewModule() {
+  if (!timestampPreviewModulePromise) {
+    const source = readFileSync(
+      path.resolve(__dirname, "../frontend/js/utils/timestampPreview.js"),
+      "utf8"
+    );
+    const url = `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`;
+
+    timestampPreviewModulePromise = import(url);
+  }
+
+  return timestampPreviewModulePromise;
+}
+
+function createTableMeta() {
+  return {
+    columns: [
+      { name: "id", primaryKeyPosition: 1 },
+      { name: "parent_id", primaryKeyPosition: 0 },
+      { name: "created_at", primaryKeyPosition: 0 },
+      { name: "updated_at", primaryKeyPosition: 0 },
+      { name: "published_at", primaryKeyPosition: 0 },
+      { name: "price", primaryKeyPosition: 0 },
+    ],
+    foreignKeys: [
+      {
+        mappings: [{ from: "parent_id", to: "id" }],
+      },
+    ],
+  };
+}
+
+test("row editor timestamp preview protects primary and foreign keys", async () => {
+  const {
+    getTimestampPreviewForField,
+    isProtectedKeyColumn,
+  } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(isProtectedKeyColumn("id", tableMeta), true);
+  assert.equal(isProtectedKeyColumn("parent_id", tableMeta), true);
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "protected-key"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "parent_id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "protected-key"
+  );
+});
+
+test("row editor timestamp preview formats plausible non-key timestamp values", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  const createdAtPreview = getTimestampPreviewForField({
+    columnName: "created_at",
+    value: "1717682400",
+    tableMeta,
+  });
+  const updatedAtPreview = getTimestampPreviewForField({
+    columnName: "updated_at",
+    value: "1717682400000",
+    tableMeta,
+  });
+  const pricePreview = getTimestampPreviewForField({
+    columnName: "price",
+    value: "1717682400",
+    tableMeta,
+  });
+  const publishedAtPreview = getTimestampPreviewForField({
+    columnName: "published_at",
+    value: "1717682400000000",
+    tableMeta,
+  });
+
+  assert.equal(createdAtPreview.kind, "timestamp");
+  assert.equal(createdAtPreview.sourceFormat, "unix-seconds");
+  assert.equal(updatedAtPreview.kind, "timestamp");
+  assert.equal(updatedAtPreview.sourceFormat, "unix-milliseconds");
+  assert.equal(publishedAtPreview.kind, "timestamp");
+  assert.equal(publishedAtPreview.sourceFormat, "unix-microseconds");
+  assert.equal(pricePreview.kind, "timestamp");
+  assert.match(createdAtPreview.formatted, /^\d{2}\.\d{2}\.\d{4}, \d{2}:\d{2}:\d{2}$/);
+});
+
+test("row editor timestamp preview ignores ids and invalid timestamps", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "external_id",
+      value: "1717682400",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "42",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "not a timestamp",
+      tableMeta,
+    }).kind,
+    "none"
+  );
+});
+
+test("row editor timestamp preview accepts ISO and SQLite datetime strings", async () => {
+  const { getTimestampPreviewForField } = await loadTimestampPreviewModule();
+  const tableMeta = createTableMeta();
+
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "created_at",
+      value: "2026-06-06T18:49:00Z",
+      tableMeta,
+    }).kind,
+    "timestamp"
+  );
+  assert.equal(
+    getTimestampPreviewForField({
+      columnName: "updated_at",
+      value: "2026-06-06 18:49:00",
+      tableMeta,
+    }).kind,
+    "timestamp"
+  );
+});
+
+test("row update stores the submitted raw value without date conversion", () => {
+  const db = new Database(":memory:");
+
+  try {
+    db.exec(`
+      CREATE TABLE events (
+        id INTEGER PRIMARY KEY,
+        created_at TEXT
+      );
+      INSERT INTO events (id, created_at) VALUES (1, 'before');
+    `);
+
+    const service = new DataBrowserService({
+      connectionManager: {
+        assertWritable() {},
+        getActiveDatabase: () => db,
+      },
+    });
+    const tableData = service.getTableData("events", { limit: 10, offset: 0 });
+    const identity = tableData.rows[0].__identity;
+
+    service.updateTableRow("events", {
+      identity,
+      values: {
+        created_at: "1717682400",
+      },
+    });
+
+    assert.equal(
+      db.prepare("SELECT created_at FROM events WHERE id = 1").get().created_at,
+      "1717682400"
+    );
+  } finally {
+    db.close();
+  }
+});