feat: support XDG Base Directory Specification

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

Dockerfile

@@ -10,6 +10,10 @@ RUN [ "${TARGETPLATFORM}" = "linux/arm64" ] && export TAR_URL=${TAR_URL_ARM64} |
     && chmod +x /app/liwan
 
 FROM scratch
+
+ENV LIWAN_CONFIG=/app/liwan.config.toml
+ENV LIWAN_DATA_DIR=/data
+
 COPY --from=downloader /app/liwan /liwan
 ENTRYPOINT ["/liwan"]
-EXPOSE 8080
+EXPOSE 9042

config.example.toml

@@ -1,11 +1,13 @@
 # The base URL of the Liwan instance
-base_url="http://localhost:8080"
+base_url="http://localhost:9042"
 
 # The port to listen on (http)
-port=8080
+port=9042
 
-# Folder to store the database in (Will be created if it doesn't exist)
-data_dir="./liwan-data"
+# # Folder to store the database in (Will be created if it doesn't exist)
+# # defaults to ./.local/share/liwan/data (or $XDG_DATA_HOME/liwan/data) on linux/macos
+# # defaults to ./liwan-data on other platforms
+# data_dir="./liwan-data"
 
 # GeoIp settings (Optional)
 [geoip]

src/cli.rs

@@ -45,7 +45,11 @@ pub(crate) struct SeedDatabase {}
 #[derive(FromArgs)]
 #[argh(subcommand, name = "generate-config")]
 /// Save a default configuration file to `liwan.config.toml`
-pub(crate) struct GenConfig {}
+pub(crate) struct GenConfig {
+    #[argh(option, short = 'o')]
+    /// the path to write the configuration file to
+    output: Option<String>,
+}
 
 #[derive(FromArgs)]
 #[argh(subcommand, name = "update-password")]
@@ -114,13 +118,14 @@ pub(crate) fn handle_command(mut config: Config, cmd: Command) -> Result<()> {
 
             println!("User {} created", add.username);
         }
-        Command::GenerateConfig(_) => {
-            if std::path::Path::new("liwan.config.toml").exists() {
+        Command::GenerateConfig(GenConfig { output }) => {
+            let output = output.unwrap_or_else(|| "liwan.config.toml".to_string());
+            if std::path::Path::new(&output).exists() {
                 println!("Configuration file already exists");
                 return Ok(());
             }
 
-            std::fs::write("liwan.config.toml", DEFAULT_CONFIG)?;
+            std::fs::write(&output, DEFAULT_CONFIG)?;
             println!("Configuration file written to liwan.config.toml");
         }
         #[cfg(debug_assertions)]

src/config.rs

@@ -6,14 +6,25 @@ use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
 fn default_base() -> String {
-    "http://localhost:8080".to_string()
+    "http://localhost:9042".to_string()
 }
 
 fn default_port() -> u16 {
-    8080
+    9042
 }
 
 fn default_data_dir() -> String {
+    #[cfg(target_family = "unix")]
+    {
+        if std::path::Path::new("~/.local/share").exists() {
+            return "~/.local/share/liwan/data".to_string();
+        }
+        std::env::var("XDG_DATA_HOME")
+            .map(|home| format!("{}/liwan/data", home))
+            .unwrap_or_else(|_| "./liwan-data".to_string())
+    }
+
+    #[cfg(not(target_family = "unix"))]
     "./liwan-data".to_string()
 }
 
@@ -45,7 +56,22 @@ impl Config {
     pub(crate) fn load(path: Option<String>) -> Result<Self> {
         tracing::debug!(path = ?path, "loading config");
 
+        let path = path.or_else(|| std::env::var("LIWAN_CONFIG").ok());
+
+        #[cfg(target_family = "unix")]
+        let path = path.or_else(|| match std::env::var("XDG_CONFIG_HOME") {
+            Ok(home) => Some(format!("{}/liwan/config.toml", home)),
+            Err(_) => {
+                if std::path::Path::new("~/.config").exists() {
+                    Some("~/.config/liwan/config.toml".to_string())
+                } else {
+                    None
+                }
+            }
+        });
+
         let config: Config = Figment::new()
+            .merge(Toml::file("liwan.config.toml".to_string()))
             .merge(Toml::file(path.unwrap_or("liwan.config.toml".to_string())))
             .merge(Env::raw().filter_map(|key| match key {
                 k if !k.starts_with("LIWAN_") => None,
@@ -102,7 +128,7 @@ mod test {
             assert_eq!(config.geoip.as_ref().unwrap().maxmind_db_path, Some("test".to_string()));
             assert_eq!(config.base_url, "http://localhost:8081");
             assert_eq!(config.data_dir, "./liwan-test-data");
-            assert_eq!(config.port, 8080);
+            assert_eq!(config.port, 9042);
             Ok(())
         });
     }
@@ -123,7 +149,7 @@ mod test {
             assert!(config.geoip.is_none());
             assert_eq!(config.base_url, "http://localhost:8081");
             assert_eq!(config.data_dir, "./liwan-test-data");
-            assert_eq!(config.port, 8080);
+            assert_eq!(config.port, 9042);
             Ok(())
         });
     }
@@ -133,9 +159,8 @@ mod test {
         Jail::expect_with(|_jail| {
             let config = Config::load(None).expect("failed to load config");
             assert!(config.geoip.is_none());
-            assert_eq!(config.base_url, "http://localhost:8080");
-            assert_eq!(config.data_dir, "./liwan-data");
-            assert_eq!(config.port, 8080);
+            assert_eq!(config.base_url, "http://localhost:9042");
+            assert_eq!(config.port, 9042);
             Ok(())
         });
     }

web/astro.config.ts

@@ -6,7 +6,7 @@ const dirname = path.dirname(new URL(import.meta.url).pathname);
 
 const proxy = {
 	"/api": {
-		target: "http://localhost:8080",
+		target: "http://localhost:9042",
 		changeOrigin: true,
 		cookieDomainRewrite: "localhost:4321",
 	},

web/package.json

@@ -5,7 +5,8 @@
 	"scripts": {
 		"dev": "bun run --bun astro dev",
 		"build": "bun run --bun astro build",
-		"preview": "bun run --bun astro preview"
+		"preview": "bun run --bun astro preview",
+		"typecheck": "bun run --bun tsc --noEmit"
 	},
 	"dependencies": {
 		"@astrojs/react": "^3.6.2",

web/src/api/index.ts

@@ -1,8 +1,8 @@
-import { createClient, type NormalizeOAS, type OASModel } from "fets";
+import { type NormalizeOAS, type OASModel, createClient } from "fets";
 export { queryClient, useMutation, useQuery, getUsername } from "./utils";
+import { useMemo } from "react";
 import type dashboardspec from "./dashboard";
 import { queryClient, useQuery } from "./utils";
-import { useMemo } from "react";
 
 export type DashboardSpec = NormalizeOAS<typeof dashboardspec>;
 export type Metric = OASModel<DashboardSpec, "Metric">;

web/src/api/utils.ts

@@ -1,11 +1,11 @@
 import {
-	QueryClient,
-	useQuery as _useQuery,
-	useMutation as _useMutation,
 	type DefaultError,
+	QueryClient,
 	type QueryKey,
 	type UseQueryOptions,
 	type UseQueryResult,
+	useMutation as _useMutation,
+	useQuery as _useQuery,
 } from "@tanstack/react-query";
 
 // get the username cookie or undefined if not set

web/src/components/dialog.tsx

@@ -1,5 +1,5 @@
-import styles from "./dialog.module.css";
 import * as Dia from "@radix-ui/react-dialog";
+import styles from "./dialog.module.css";
 
 export const Dialog = ({
 	title,

web/src/components/dimensions/index.tsx

@@ -1,17 +1,17 @@
-import styles from "./dimensions.module.css";
-import { LinkIcon } from "lucide-react";
 import * as Tabs from "@radix-ui/react-tabs";
+import { LinkIcon } from "lucide-react";
+import styles from "./dimensions.module.css";
 
 import {
-	dimensionNames,
-	formatMetricVal,
-	metricNames,
-	useDimension,
 	type DateRange,
 	type Dimension,
 	type DimensionTableRow,
 	type Metric,
 	type ProjectResponse,
+	dimensionNames,
+	formatMetricVal,
+	metricNames,
+	useDimension,
 } from "../../api";
 
 import { BrowserIcon, MobileDeviceIcon, OSIcon, ReferrerIcon } from "../icons";
@@ -86,25 +86,9 @@ export const DimensionTable = ({
 	range,
 }: { project: ProjectResponse; dimension: Dimension; metric: Metric; range: DateRange; noHeader?: boolean }) => {
 	const { data, biggest, order } = useDimension({ project, dimension, metric, range });
-	return <DimensionList value={data ?? []} dimension={dimension} metric={metric} biggest={biggest} order={order} />;
-};
-
-export const DimensionList = ({
-	value,
-	dimension,
-	metric,
-	biggest,
-	order,
-}: {
-	value: DimensionTableRow[];
-	dimension: Dimension;
-	metric: Metric;
-	biggest: number;
-	order?: string[];
-}) => {
 	return (
 		<div>
-			{value.map((d) => {
+			{data?.map((d) => {
 				return (
 					<div
 						key={d.dimensionValue}