feat: add SQLite support for meta database and update Docker configuration

Author: JulianFun123

Dockerfile.backend

@@ -1,4 +1,27 @@
-FROM node:24-bookworm-slim AS deps
+FROM node:24-bookworm-slim AS frontend-build
+
+WORKDIR /app
+
+RUN corepack enable
+
+ARG VITE_LOCKED_SERVER_URL=/
+ARG VITE_LOCKED_SERVER_NAME=StarQuery Hosted
+ENV VITE_LOCKED_SERVER_URL=$VITE_LOCKED_SERVER_URL
+ENV VITE_LOCKED_SERVER_NAME=$VITE_LOCKED_SERVER_NAME
+
+COPY .npmrc .npmrc
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY packages/frontend/package.json packages/frontend/package.json
+
+RUN pnpm install --filter frontend... --frozen-lockfile
+
+COPY packages/frontend packages/frontend
+
+WORKDIR /app/packages/frontend
+
+RUN pnpm build
+
+FROM node:24-bookworm-slim AS backend-deps
 
 WORKDIR /app
 
@@ -7,6 +30,7 @@ RUN apt-get update \
   && apt-get install -y --no-install-recommends python3 make g++ \
   && rm -rf /var/lib/apt/lists/*
 
+COPY .npmrc .npmrc
 COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
 COPY packages/backend/package.json packages/backend/package.json
 
@@ -16,16 +40,26 @@ FROM node:24-bookworm-slim
 
 WORKDIR /app
 
-RUN corepack enable
-
-COPY --from=deps /app/node_modules ./node_modules
-COPY --from=deps /app/package.json ./package.json
-COPY --from=deps /app/pnpm-lock.yaml ./pnpm-lock.yaml
-COPY --from=deps /app/pnpm-workspace.yaml ./pnpm-workspace.yaml
+COPY --from=backend-deps /app/node_modules ./node_modules
+COPY --from=backend-deps /app/package.json ./package.json
+COPY --from=backend-deps /app/pnpm-lock.yaml ./pnpm-lock.yaml
+COPY --from=backend-deps /app/pnpm-workspace.yaml ./pnpm-workspace.yaml
 COPY packages/backend packages/backend
+COPY --from=frontend-build /app/packages/frontend/dist /app/packages/frontend/dist
+
+RUN mkdir -p /var/lib/starquery
 
 WORKDIR /app/packages/backend
 
-EXPOSE 3000
+ENV NODE_ENV=production
+ENV HOST=0.0.0.0
+ENV PORT=8080
+ENV STARQUERY_MODE=hosted
+ENV STARQUERY_SERVER_NAME="StarQuery Hosted"
+ENV STARQUERY_META_DRIVER=sqlite
+ENV STARQUERY_META_SQLITE_PATH=/var/lib/starquery/starquery-meta.sqlite
+ENV STARQUERY_FRONTEND_DIST_PATH=/app/packages/frontend/dist
+
+EXPOSE 8080
 
-CMD ["pnpm", "start"]
+CMD ["node", "--import", "tsx", "src/index.ts"]

README.md

@@ -2,6 +2,26 @@
 
 StarQuery is a desktop and web database/resource browser with support for SQL datasources, Elasticsearch, and S3-compatible object storage.
 
+## Docker Quick Start
+
+Run the prebuilt single-image deployment:
+
+```bash
+docker run -it --rm \
+  -p 8080:8080 \
+  --add-host=host.docker.internal:host-gateway \
+  -v starquery-data:/var/lib/starquery \
+  interaapps/starquery
+```
+
+Then open:
+
+- App: `http://localhost:8080`
+
+Networking note:
+- If StarQuery inside the container should connect to services running on your host machine, use `host.docker.internal` as the host in your datasource config instead of `localhost`.
+- The `--add-host=host.docker.internal:host-gateway` flag makes that work on Linux as well.
+
 Status:
 - Work in progress
 - No stable releases yet
@@ -39,7 +59,8 @@ Runtime targets:
 
 - Intended for self-hosting on a server
 - Auth is enabled by default
-- Uses MySQL as the default meta database
+- Uses MySQL as the default meta database in the generic backend config
+- The published Docker image uses SQLite for the meta database by default so no extra DB is required
 - Can optionally bootstrap users, projects, and datasources from JSON
 
 ### Plain web frontend
@@ -73,9 +94,10 @@ Use `docker compose down -v` if you want to wipe the database and re-run the see
 ## Hosted Docker Deployment
 
 There is a dedicated Docker deployment for the hosted web version with:
-- a Vite-built frontend served by Nginx
-- a Node backend
-- a MySQL metastore for users, roles, projects, datasources, tokens, and settings
+- one Node app image that serves both the built frontend and the backend API
+- a SQLite metastore by default, stored in a Docker volume
+
+This means the default self-hosted setup does not require any separate database container or database configuration.
 
 Start it with:
 
@@ -85,12 +107,21 @@ docker compose -f docker-compose.hosted.yml up -d --build
 
 Then open:
 
-- Frontend: `http://localhost:8080`
+- App: `http://localhost:8080`
+
+You can also run the single image directly without compose:
+
+```bash
+docker build -t starquery -f Dockerfile.backend .
+docker run -it --rm \
+  -p 8080:8080 \
+  --add-host=host.docker.internal:host-gateway \
+  -v starquery-data:/var/lib/starquery \
+  starquery
+```
 
 Services in the hosted stack:
-- `frontend`: public web UI on port `8080`
-- `backend`: internal StarQuery API in `hosted` mode
-- `meta-db`: MySQL database used by the backend as its metastore
+- `app`: public StarQuery web UI and backend API on port `8080`
 
 Stop it with:
 
@@ -104,6 +135,14 @@ Reset the hosted metastore volume with:
 docker compose -f docker-compose.hosted.yml down -v
 ```
 
+The hosted compose file now uses:
+- `STARQUERY_META_DRIVER=sqlite`
+- `STARQUERY_META_SQLITE_PATH=/var/lib/starquery/starquery-meta.sqlite`
+- `VITE_LOCKED_SERVER_URL=/`
+- `PORT=8080`
+
+If you prefer MySQL for the metastore, you can still switch the backend to MySQL by providing the normal `STARQUERY_META_MYSQL_*` environment variables in your own compose override.
+
 ## Configuration Overview
 
 There are three main configuration surfaces:
@@ -145,7 +184,7 @@ These are read by the StarQuery backend.
 
 | Variable | Default | Description |
 | --- | --- | --- |
-| `STARQUERY_META_DRIVER` | `mysql` in hosted mode, `sqlite` in local mode | Meta database driver. Valid values: `mysql`, `sqlite`. |
+| `STARQUERY_META_DRIVER` | `mysql` in hosted mode, `sqlite` in local mode | Meta database driver. Valid values: `mysql`, `sqlite`. The bundled Docker hosted deployment overrides this to `sqlite` by default so no extra DB is required. |
 | `STARQUERY_META_SQLITE_PATH` | `<cwd>/.starquery/starquery-meta.sqlite` | SQLite file path for the meta database. Only used when `STARQUERY_META_DRIVER=sqlite`. |
 | `STARQUERY_META_MYSQL_HOST` | `127.0.0.1` | MySQL host for the meta database. |
 | `STARQUERY_META_MYSQL_PORT` | `3307` | MySQL port for the meta database. |

docker-compose.hosted.yml

@@ -1,52 +1,23 @@
 services:
-  frontend:
-    build:
-      context: .
-      dockerfile: Dockerfile.frontend
-    depends_on:
-      - backend
-    ports:
-      - '8080:80'
-    restart: unless-stopped
-
-  backend:
+  app:
     build:
       context: .
       dockerfile: Dockerfile.backend
-    depends_on:
-      meta-db:
-        condition: service_healthy
+      args:
+        VITE_LOCKED_SERVER_URL: /
+        VITE_LOCKED_SERVER_NAME: StarQuery Hosted
     environment:
       HOST: 0.0.0.0
-      PORT: 3000
+      PORT: 8080
       STARQUERY_MODE: hosted
       STARQUERY_SERVER_NAME: StarQuery Hosted
-      STARQUERY_META_DRIVER: mysql
-      STARQUERY_META_MYSQL_HOST: meta-db
-      STARQUERY_META_MYSQL_PORT: 3306
-      STARQUERY_META_MYSQL_USER: starquery
-      STARQUERY_META_MYSQL_PASSWORD: starquery
-      STARQUERY_META_MYSQL_DATABASE: starquery
-    expose:
-      - '3000'
-    restart: unless-stopped
-
-  meta-db:
-    image: mysql:8.4
-    environment:
-      MYSQL_ROOT_PASSWORD: root
-      MYSQL_DATABASE: starquery
-      MYSQL_USER: starquery
-      MYSQL_PASSWORD: starquery
+      STARQUERY_META_DRIVER: sqlite
+      STARQUERY_META_SQLITE_PATH: /var/lib/starquery/starquery-meta.sqlite
+    ports:
+      - '8080:8080'
     volumes:
-      - starquery-meta-data:/var/lib/mysql
-    healthcheck:
-      test: ['CMD-SHELL', 'mysqladmin ping -h 127.0.0.1 -uroot -p$$MYSQL_ROOT_PASSWORD']
-      interval: 10s
-      timeout: 5s
-      retries: 12
-      start_period: 20s
+      - starquery-app-data:/var/lib/starquery
     restart: unless-stopped
 
 volumes:
-  starquery-meta-data:
+  starquery-app-data:

packages/backend/src/auth/cors.test.ts

@@ -59,6 +59,12 @@ test('hosted CORS allows the configured public origin', async () => {
   assert.equal(await evaluateOrigin(config, 'https://evil.example.com'), false)
 })
 
+test('hosted CORS allows every origin when wildcard is configured', async () => {
+  const config = createConfig({ corsAllowedOrigins: ['*'] })
+  assert.equal(await evaluateOrigin(config, 'http://localhost:5173'), true)
+  assert.equal(await evaluateOrigin(config, 'https://evil.example.com'), true)
+})
+
 test('local mode keeps broad CORS for the desktop app flow', () => {
   const config = createConfig({ mode: 'local' })
   const options = createCorsOptions(config)

packages/backend/src/auth/cors.ts

@@ -16,6 +16,7 @@ export function createCorsOptions(config: AppConfig): CorsOptions {
     }
   }
 
+  const allowAnyOrigin = config.corsAllowedOrigins.some((origin) => origin.trim() === '*')
   const allowedOrigins = new Set(
     [
       ...config.corsAllowedOrigins.map((origin) => normalizeOrigin(origin)).filter((origin): origin is string => Boolean(origin)),
@@ -25,6 +26,11 @@ export function createCorsOptions(config: AppConfig): CorsOptions {
 
   return {
     origin(origin, callback) {
+      if (allowAnyOrigin) {
+        callback(null, true)
+        return
+      }
+
       if (!origin) {
         callback(null, true)
         return

packages/backend/src/config/app-config.ts

@@ -8,6 +8,7 @@ export type AppConfig = {
   host: string
   publicUrl?: string
   corsAllowedOrigins: string[]
+  frontendDistPath?: string
   serverName: string
   mode: AppMode
   requestBodyLimit: string
@@ -63,6 +64,8 @@ export function loadAppConfig(): AppConfig {
       .split(',')
       .map((entry) => entry.trim())
       .filter(Boolean),
+    frontendDistPath:
+      process.env.STARQUERY_FRONTEND_DIST_PATH?.trim() || path.resolve(process.cwd(), '..', 'frontend', 'dist'),
     serverName:
       process.env.STARQUERY_SERVER_NAME ?? (mode === 'hosted' ? 'Hosted Server' : 'Local Computer'),
     mode,

packages/backend/src/meta/connection.ts

@@ -33,41 +33,59 @@ function normalizeSqliteRows(rows: unknown[]) {
   })
 }
 
+function normalizeSqliteParam(param: unknown) {
+  if (typeof param === 'boolean') {
+    return param ? 1 : 0
+  }
+
+  if (param instanceof Date) {
+    return param.toISOString()
+  }
+
+  return param
+}
+
+function normalizeSqliteParams(params: unknown[]) {
+  return params.map((param) => normalizeSqliteParam(param))
+}
+
 function normalizeSqliteRow(row: unknown) {
   return normalizeSqliteRows([row])[0] ?? []
 }
 
 function createSqliteProxyCallback(connection: SqliteConnection) {
   return async (query: string, params: unknown[], method: SqliteMethod) => {
     const statement = connection.prepare(query)
+    const normalizedParams = normalizeSqliteParams(params)
 
     if (method === 'run') {
-      statement.run(...params)
+      statement.run(...normalizedParams)
       return { rows: [] }
     }
 
     if (method === 'get') {
-      const row = statement.get(...params)
+      const row = statement.get(...normalizedParams)
       return { rows: row === undefined ? [] : [normalizeSqliteRow(row)] }
     }
 
-    const rows = statement.all(...params)
+    const rows = statement.all(...normalizedParams)
     return { rows: normalizeSqliteRows(rows as unknown[]) }
   }
 }
 
 function executeSqlite(connection: SqliteConnection, statement: string, params: unknown[] = []) {
   const prepared = connection.prepare(statement)
+  const normalizedParams = normalizeSqliteParams(params)
   const normalizedStatement = statement.trim().toLowerCase()
   if (
     normalizedStatement.startsWith('select') ||
     normalizedStatement.startsWith('pragma') ||
     normalizedStatement.startsWith('with')
   ) {
-    return prepared.all(...params) as unknown[]
+    return prepared.all(...normalizedParams) as unknown[]
   }
 
-  prepared.run(...params)
+  prepared.run(...normalizedParams)
   return []
 }
 

packages/backend/src/server.ts

@@ -14,6 +14,7 @@ import { registerAuthRoutes } from './routes/auth-routes.ts'
 import { registerProjectRoutes } from './routes/projects-routes.ts'
 import { registerServerRoutes } from './routes/server-routes.ts'
 import { registerSourceRoutes } from './routes/source-routes.ts'
+import { registerStaticFrontend } from './static-frontend.ts'
 
 export type StartBackendServerOptions = Partial<Omit<AppConfig, 'metaStore' | 'auth'>> & {
   auth?: Partial<Omit<AppConfig['auth'], 'seedAdmin' | 'openId'>> & {
@@ -76,6 +77,7 @@ export async function startBackendServer(overrides: StartBackendServerOptions =
   registerAdminRoutes(app, context)
   registerProjectRoutes(app, context)
   registerSourceRoutes(app, context)
+  registerStaticFrontend(app, config)
 
   const server = await new Promise<Server>((resolve, reject) => {
     const httpServer = app.listen(config.port, config.host, () => resolve(httpServer))