sqlite-hub 0.1.3

package/server/utils/errors.js

@@ -0,0 +1,175 @@
+class AppError extends Error {
+  constructor(message, statusCode = 500, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.code = options.code ?? "APP_ERROR";
+    this.details = options.details ?? null;
+    this.sqliteCode = options.sqliteCode ?? null;
+    this.warnings = options.warnings ?? [];
+    this.expose = options.expose ?? true;
+  }
+}
+
+class ValidationError extends AppError {
+  constructor(message, options = {}) {
+    super(message, 400, { code: "VALIDATION_ERROR", ...options });
+  }
+}
+
+class NotFoundError extends AppError {
+  constructor(message, options = {}) {
+    super(message, 404, { code: "NOT_FOUND", ...options });
+  }
+}
+
+class ConflictError extends AppError {
+  constructor(message, options = {}) {
+    super(message, 409, { code: "CONFLICT", ...options });
+  }
+}
+
+class BusyError extends AppError {
+  constructor(message, options = {}) {
+    super(message, 423, { code: "SQLITE_BUSY", ...options });
+  }
+}
+
+class ReadOnlyError extends AppError {
+  constructor(message, options = {}) {
+    super(message, 403, { code: "SQLITE_READONLY", ...options });
+  }
+}
+
+class DatabaseRequiredError extends AppError {
+  constructor(message = "No active SQLite database selected.", options = {}) {
+    super(message, 400, { code: "ACTIVE_DATABASE_REQUIRED", ...options });
+  }
+}
+
+function mapSqliteError(error) {
+  if (!error) {
+    return new AppError("Unknown error");
+  }
+
+  if (error instanceof AppError) {
+    return error;
+  }
+
+  const code = error.code ?? "";
+  const message = error.message ?? "Unexpected error";
+
+  if (code.includes("SQLITE_BUSY") || code.includes("SQLITE_LOCKED")) {
+    return new BusyError(message, {
+      details: error,
+      sqliteCode: code,
+    });
+  }
+
+  if (code.includes("SQLITE_READONLY")) {
+    return new ReadOnlyError(message, {
+      details: error,
+      sqliteCode: code,
+    });
+  }
+
+  if (
+    code.includes("SQLITE_ERROR") ||
+    code.includes("SQLITE_CONSTRAINT") ||
+    code.includes("SQLITE_MISMATCH") ||
+    code.includes("SQLITE_RANGE")
+  ) {
+    return new ValidationError(message, {
+      code: code || "SQLITE_ERROR",
+      details: error,
+      sqliteCode: code || null,
+    });
+  }
+
+  if (message.includes("file is not a database")) {
+    return new ValidationError(message, {
+      code: "SQLITE_INVALID_DATABASE",
+      details: error,
+      sqliteCode: code || null,
+    });
+  }
+
+  return new AppError(message, 500, {
+    code: code || "INTERNAL_ERROR",
+    details: error,
+    sqliteCode: code || null,
+  });
+}
+
+function successResponse({
+  data = null,
+  metadata = {},
+  message = "",
+  warnings = [],
+  timingMs = null,
+  readOnly = undefined,
+} = {}) {
+  const response = {
+    success: true,
+    message,
+    data,
+    metadata,
+    warnings,
+  };
+
+  if (typeof timingMs === "number") {
+    response.timingMs = timingMs;
+  }
+
+  if (typeof readOnly === "boolean") {
+    response.readOnly = readOnly;
+  }
+
+  return response;
+}
+
+function errorResponse(error) {
+  const normalized = mapSqliteError(error);
+
+  return {
+    success: false,
+    message: normalized.message,
+    error: {
+      code: normalized.code,
+      message: normalized.message,
+      details: normalized.details,
+      sqliteCode: normalized.sqliteCode,
+    },
+    warnings: normalized.warnings ?? [],
+  };
+}
+
+function route(handler) {
+  return async (req, res, next) => {
+    try {
+      await handler(req, res, next);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+function errorMiddleware(error, req, res, next) {
+  const normalized = mapSqliteError(error);
+  res.status(normalized.statusCode).json(errorResponse(normalized));
+}
+
+module.exports = {
+  AppError,
+  BusyError,
+  ConflictError,
+  DatabaseRequiredError,
+  NotFoundError,
+  ReadOnlyError,
+  ValidationError,
+  errorMiddleware,
+  errorResponse,
+  mapSqliteError,
+  route,
+  successResponse,
+};

package/server/utils/fileValidation.js

@@ -0,0 +1,135 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { ConflictError, NotFoundError, ValidationError } = require("./errors");
+
+const SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3"]);
+const SQL_DUMP_EXTENSIONS = new Set([".sql"]);
+const SQLITE_HEADER = Buffer.from("SQLite format 3\0", "utf8");
+
+function expandHome(filePath) {
+  if (typeof filePath !== "string" || !filePath.trim()) {
+    throw new ValidationError("A file path is required.");
+  }
+
+  if (filePath === "~") {
+    return os.homedir();
+  }
+
+  if (filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+
+  return filePath;
+}
+
+function resolveUserPath(filePath) {
+  return path.resolve(expandHome(filePath));
+}
+
+function assertExtension(filePath, allowedExtensions, label) {
+  const extension = path.extname(filePath).toLowerCase();
+
+  if (!allowedExtensions.has(extension)) {
+    throw new ValidationError(
+      `${label} must use one of: ${Array.from(allowedExtensions).join(", ")}`
+    );
+  }
+}
+
+function ensureFileExists(filePath, label = "File") {
+  if (!fs.existsSync(filePath)) {
+    throw new NotFoundError(`${label} does not exist: ${filePath}`);
+  }
+}
+
+function ensureFileDoesNotExist(filePath, label = "File") {
+  if (fs.existsSync(filePath)) {
+    throw new ConflictError(`${label} already exists: ${filePath}`);
+  }
+}
+
+function ensureParentDirectory(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function readSqliteHeader(filePath) {
+  const handle = fs.openSync(filePath, "r");
+
+  try {
+    const header = Buffer.alloc(SQLITE_HEADER.length);
+    const bytesRead = fs.readSync(handle, header, 0, SQLITE_HEADER.length, 0);
+    return header.subarray(0, bytesRead);
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
+function isRealSqliteDatabase(filePath) {
+  ensureFileExists(filePath, "SQLite database");
+
+  const stat = fs.statSync(filePath);
+
+  if (!stat.isFile()) {
+    throw new ValidationError(`SQLite database path is not a file: ${filePath}`);
+  }
+
+  if (stat.size < SQLITE_HEADER.length) {
+    return false;
+  }
+
+  return readSqliteHeader(filePath).equals(SQLITE_HEADER);
+}
+
+function validateSqlitePath(inputPath, { mustExist = true } = {}) {
+  const filePath = resolveUserPath(inputPath);
+  assertExtension(filePath, SQLITE_EXTENSIONS, "SQLite database");
+
+  if (mustExist) {
+    ensureFileExists(filePath, "SQLite database");
+
+    if (!isRealSqliteDatabase(filePath)) {
+      throw new ValidationError(`File is not a valid SQLite database: ${filePath}`);
+    }
+  }
+
+  return filePath;
+}
+
+function validateSqlDumpPath(inputPath) {
+  const filePath = resolveUserPath(inputPath);
+  assertExtension(filePath, SQL_DUMP_EXTENSIONS, "SQL dump");
+  ensureFileExists(filePath, "SQL dump");
+  return filePath;
+}
+
+function isWritable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.W_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function getFileMetadata(filePath) {
+  const stat = fs.statSync(filePath);
+
+  return {
+    path: filePath,
+    sizeBytes: stat.size,
+    lastModifiedAt: stat.mtime.toISOString(),
+  };
+}
+
+module.exports = {
+  SQLITE_EXTENSIONS,
+  ensureFileDoesNotExist,
+  ensureParentDirectory,
+  getFileMetadata,
+  isRealSqliteDatabase,
+  isWritable,
+  resolveUserPath,
+  validateSqlDumpPath,
+  validateSqlitePath,
+};

package/server/utils/identifier.js

@@ -0,0 +1,38 @@
+const { ValidationError } = require("./errors");
+
+function assertValidIdentifier(identifier, label = "Identifier") {
+  if (typeof identifier !== "string" || !identifier.trim()) {
+    throw new ValidationError(`${label} is required.`);
+  }
+
+  if (identifier.includes("\0")) {
+    throw new ValidationError(`${label} contains invalid characters.`);
+  }
+
+  return identifier;
+}
+
+function quoteIdentifier(identifier) {
+  return `"${assertValidIdentifier(identifier).replaceAll('"', '""')}"`;
+}
+
+function ensureKnownIdentifier(identifier, allowed, label = "Identifier") {
+  assertValidIdentifier(identifier, label);
+
+  if (!allowed.includes(identifier)) {
+    throw new ValidationError(`${label} is not part of the current SQLite schema.`);
+  }
+
+  return identifier;
+}
+
+function quoteIdentifierList(identifiers) {
+  return identifiers.map((identifier) => quoteIdentifier(identifier)).join(", ");
+}
+
+module.exports = {
+  assertValidIdentifier,
+  ensureKnownIdentifier,
+  quoteIdentifier,
+  quoteIdentifierList,
+};

package/server/utils/sqliteTypes.js

@@ -0,0 +1,112 @@
+const { Buffer } = require("node:buffer");
+
+function normalizeDeclaredType(type) {
+  const declaredType = String(type ?? "").trim().toUpperCase();
+
+  if (!declaredType) {
+    return {
+      declaredType: "",
+      affinity: "BLOB",
+    };
+  }
+
+  if (declaredType.includes("INT")) {
+    return { declaredType, affinity: "INTEGER" };
+  }
+
+  if (
+    declaredType.includes("CHAR") ||
+    declaredType.includes("CLOB") ||
+    declaredType.includes("TEXT")
+  ) {
+    return { declaredType, affinity: "TEXT" };
+  }
+
+  if (declaredType.includes("BLOB")) {
+    return { declaredType, affinity: "BLOB" };
+  }
+
+  if (
+    declaredType.includes("REAL") ||
+    declaredType.includes("FLOA") ||
+    declaredType.includes("DOUB")
+  ) {
+    return { declaredType, affinity: "REAL" };
+  }
+
+  return { declaredType, affinity: "NUMERIC" };
+}
+
+function serializeBlob(buffer) {
+  return {
+    __type: "blob",
+    sizeBytes: buffer.length,
+    hexPreview: buffer.subarray(0, 16).toString("hex"),
+    base64Preview: buffer.subarray(0, 24).toString("base64"),
+  };
+}
+
+function serializeSqliteValue(value) {
+  if (Buffer.isBuffer(value)) {
+    return serializeBlob(value);
+  }
+
+  if (value instanceof Uint8Array) {
+    return serializeBlob(Buffer.from(value));
+  }
+
+  return value;
+}
+
+function serializeRow(row) {
+  return Object.fromEntries(
+    Object.entries(row).map(([key, value]) => [key, serializeSqliteValue(value)])
+  );
+}
+
+function serializeRows(rows) {
+  return rows.map((row) => serializeRow(row));
+}
+
+function decodeBlobPayload(payload) {
+  const encoding = payload.encoding ?? "base64";
+  const rawData = payload.data ?? payload.value ?? "";
+
+  if (typeof rawData !== "string") {
+    throw new Error("BLOB payload data must be a string.");
+  }
+
+  if (encoding === "hex") {
+    return Buffer.from(rawData, "hex");
+  }
+
+  if (encoding === "base64") {
+    return Buffer.from(rawData, "base64");
+  }
+
+  throw new Error(`Unsupported BLOB encoding: ${encoding}`);
+}
+
+function deserializeSqliteValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (value && typeof value === "object" && value.__type === "blob") {
+    return decodeBlobPayload(value);
+  }
+
+  if (Array.isArray(value) || (value && typeof value === "object")) {
+    return JSON.stringify(value);
+  }
+
+  return value;
+}
+
+module.exports = {
+  deserializeSqliteValue,
+  normalizeDeclaredType,
+  serializeRow,
+  serializeRows,
+  serializeSqliteValue,
+};

package/styles/base.css

@@ -0,0 +1,176 @@
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  height: 100%;
+  margin: 0;
+}
+
+body {
+  background: var(--color-background);
+  color: var(--color-on-surface);
+  font-family: var(--font-family-body);
+}
+
+button,
+input,
+select,
+textarea {
+  color: inherit;
+  font: inherit;
+}
+
+button {
+  cursor: pointer;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+
+img {
+  display: block;
+  max-width: 100%;
+}
+
+[hidden] {
+  display: none !important;
+}
+
+.font-headline {
+  font-family: var(--font-family-headline);
+}
+
+.font-body {
+  font-family: var(--font-family-body);
+}
+
+.font-mono {
+  font-family: var(--font-family-mono);
+}
+
+.material-symbols-outlined {
+  display: inline-block;
+  font-size: var(--font-size-icon);
+  font-variation-settings: "FILL" 0, "wght" 400, "GRAD" 0, "opsz" 24;
+  letter-spacing: normal;
+  line-height: 1;
+  text-transform: none;
+  white-space: nowrap;
+  word-wrap: normal;
+  direction: ltr;
+  vertical-align: middle;
+}
+
+.no-scrollbar {
+  -ms-overflow-style: none;
+  scrollbar-width: none;
+}
+
+.no-scrollbar::-webkit-scrollbar {
+  display: none;
+  height: 0;
+  width: 0;
+}
+
+.custom-scrollbar {
+  scrollbar-color: var(--color-surface-highest) var(--color-surface-lowest);
+  scrollbar-width: thin;
+}
+
+.custom-scrollbar::-webkit-scrollbar {
+  height: var(--scrollbar-size);
+  width: var(--scrollbar-size);
+}
+
+.custom-scrollbar::-webkit-scrollbar-track {
+  background: var(--color-surface-lowest);
+}
+
+.custom-scrollbar::-webkit-scrollbar-thumb {
+  background: var(--color-surface-highest);
+}
+
+.custom-scrollbar::-webkit-scrollbar-thumb:hover {
+  background: var(--color-primary-container);
+}
+
+.clipped-btn,
+.clipped-corner,
+.custom-clip,
+.clip-button,
+.clip-corner {
+  clip-path: var(--clip-path);
+}
+
+.sql-keyword {
+  color: var(--color-primary-container);
+}
+
+.sql-string {
+  color: var(--color-on-surface);
+}
+
+.sql-comment {
+  color: var(--color-outline-variant);
+}
+
+.sql-value {
+  color: var(--color-on-surface-variant);
+}
+
+.query-editor-layer {
+  min-height: 140px;
+}
+
+.query-editor-highlight,
+.query-editor-input {
+  font: inherit;
+  line-height: inherit;
+  margin: 0;
+  padding: 0;
+  tab-size: 2;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.query-editor-highlight {
+  color: var(--color-on-surface);
+  inset: 0;
+  overflow: hidden;
+  pointer-events: none;
+  position: absolute;
+}
+
+.query-editor-input {
+  -webkit-text-fill-color: transparent;
+  background: transparent;
+  caret-color: var(--color-on-surface);
+  color: transparent;
+  overflow: auto;
+}
+
+.query-editor-input::placeholder {
+  color: transparent;
+}
+
+.cursor-blink {
+  animation: cursor-blink var(--duration-cursor-blink) step-end infinite;
+  border-right: 2px solid var(--color-primary-container);
+}
+
+@keyframes cursor-blink {
+  from,
+  to {
+    border-color: transparent;
+  }
+
+  50% {
+    border-color: var(--color-primary-container);
+  }
+}