mongoku 2.0.1 → 2.0.3

package/src/lib/server/JsonEncoder.ts

@@ -0,0 +1,62 @@
+import { ObjectId } from "mongodb";
+
+export default class JsonEncoder {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	static encode(obj: any): any {
+		if (obj instanceof ObjectId) {
+			return {
+				$type: "ObjectId",
+				$value: obj.toHexString(),
+				$date: obj.getTimestamp().getTime(),
+			};
+		}
+		if (obj instanceof Date) {
+			return {
+				$type: "Date",
+				$value: obj.toISOString(),
+			};
+		}
+		if (obj instanceof RegExp) {
+			return {
+				$type: "RegExp",
+				$value: {
+					$pattern: obj.source,
+					$flags: obj.flags,
+				},
+			};
+		}
+		if (Array.isArray(obj)) {
+			return [...obj.map(JsonEncoder.encode)];
+		}
+		if (obj && typeof obj === "object") {
+			for (const [key, value] of Object.entries(obj)) {
+				obj[key] = JsonEncoder.encode(value);
+			}
+		}
+
+		return obj;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	static decode(obj: any): any {
+		if (obj && obj.$type === "ObjectId") {
+			return ObjectId.createFromHexString(obj.$value);
+		}
+		if (obj && obj.$type === "Date") {
+			return new Date(obj.$value);
+		}
+		if (obj && obj.$type === "RegExp") {
+			return new RegExp(obj.$value.$pattern, obj.$value.$flags);
+		}
+		if (Array.isArray(obj)) {
+			return [...obj.map(JsonEncoder.decode)];
+		}
+		if (obj && typeof obj === "object") {
+			for (const [key, value] of Object.entries(obj)) {
+				obj[key] = JsonEncoder.decode(value);
+			}
+		}
+
+		return obj;
+	}
+}

package/src/lib/server/mongo.ts

@@ -0,0 +1,199 @@
+import type { CollectionJSON } from "$lib/types";
+import { MongoClient, type Collection } from "mongodb";
+import { URL } from "url";
+import { HostsManager } from "./HostsManager";
+
+export async function getCollectionJson(
+	collection: Collection,
+	type?: "view" | "timeseries" | "collection" | string,
+): Promise<CollectionJSON> {
+	const stats = {
+		size: 0,
+		count: 0,
+		avgObjSize: 0,
+		storageSize: 0,
+		capped: false,
+		nindexes: 0,
+		totalIndexSize: 0,
+		indexSizes: {},
+	};
+
+	if (type !== "view") {
+		const agg = (await collection
+			.aggregate([
+				{
+					$collStats: {
+						storageStats: {},
+						count: {},
+					},
+				},
+			])
+			.next()
+			.catch(() => null)) as {
+			storageStats: {
+				size: number;
+				count: number;
+				storageSize: number;
+				capped: boolean;
+				nindexes: number;
+				totalIndexSize: number;
+				indexSizes: Record<string, number>;
+			};
+		} | null;
+
+		if (agg) {
+			stats.size = agg.storageStats.size;
+			stats.count = agg.storageStats.count;
+			stats.avgObjSize = Math.round(agg.storageStats.size / agg.storageStats.count);
+			stats.storageSize = agg.storageStats.storageSize;
+			stats.capped = agg.storageStats.capped;
+			stats.nindexes = agg.storageStats.nindexes;
+			stats.totalIndexSize = agg.storageStats.totalIndexSize;
+			stats.indexSizes = agg.storageStats.indexSizes;
+		}
+	}
+
+	// Get index definitions
+	let indexes: Array<{ name: string; key?: Record<string, number>; size: number }> = [];
+	if (type !== "view") {
+		try {
+			const indexList = await collection.listIndexes().toArray();
+			indexes = indexList.map((index: { name: string; key: Record<string, number> }) => ({
+				name: index.name,
+				key: index.key,
+				size: (stats.indexSizes as Record<string, number>)[index.name] || 0,
+			}));
+		} catch {
+			// If we can't get index details, fall back to indexSizes
+			indexes = Object.entries(stats.indexSizes).map(([name, size]) => ({
+				name,
+				size: size as number,
+			}));
+		}
+	}
+
+	return {
+		name: collection.collectionName,
+		size: (stats.storageSize ?? 0) + (stats.totalIndexSize ?? 0),
+		dataSize: stats.size,
+		count: stats.count,
+		avgObjSize: stats.avgObjSize ?? 0,
+		storageSize: stats.storageSize ?? 0,
+		capped: stats.capped,
+		nIndexes: stats.nindexes,
+		totalIndexSize: stats.totalIndexSize ?? 0,
+		indexSizes: stats.indexSizes,
+		indexes,
+	};
+}
+
+class MongoConnections {
+	/**
+	 * Todo: better system where we can have mutiple servers with same hostname, and labels for each server that
+	 * would be displayed in the UI instead of the hostname.
+	 */
+	private clients: Map<string, MongoClient> = new Map();
+	private clientIds: Map<string, string> = new Map(); // hostname -> _id
+	private hostsManager: HostsManager;
+	private countTimeout = parseInt(process.env.MONGOKU_COUNT_TIMEOUT!, 10) || 5000;
+
+	constructor() {
+		this.hostsManager = new HostsManager();
+	}
+
+	async initialize() {
+		await this.hostsManager.load();
+		const hosts = await this.hostsManager.getHosts();
+
+		// Create MongoClient instances without connecting (lazy connection)
+		for (const host of hosts) {
+			const urlStr = host.path.startsWith("mongodb") ? host.path : `mongodb://${host.path}`;
+			try {
+				const url = new URL(urlStr);
+				const hostname = url.host || host.path;
+
+				if (!this.clients.has(hostname)) {
+					const client = new MongoClient(urlStr);
+					this.clients.set(hostname, client);
+					this.clientIds.set(hostname, host._id);
+				}
+			} catch (err) {
+				console.error(`Failed to parse URL for host ${host.path}:`, err);
+			}
+		}
+	}
+
+	getClient(name: string): MongoClient {
+		const client = this.clients.get(name) || this.clients.get(`${name}:27017`);
+		if (!client) {
+			throw new Error("Server does not exist");
+		}
+		return client;
+	}
+
+	listClients(): Array<{ name: string; _id: string; client: MongoClient }> {
+		return Array.from(this.clients.entries())
+			.filter(([, client]) => client instanceof MongoClient)
+			.map(([name, client]) => ({
+				name,
+				_id: this.clientIds.get(name) || "",
+				client: client as MongoClient,
+			}));
+	}
+
+	getCollection(serverName: string, databaseName: string, collectionName: string) {
+		const client = this.getClient(serverName);
+		const db = client.db(databaseName);
+		return db.collection(collectionName);
+	}
+
+	getCountTimeout() {
+		return this.countTimeout;
+	}
+
+	async addServer(hostPath: string) {
+		const id = await this.hostsManager.add(hostPath);
+
+		// Add the new server client
+		const urlStr = hostPath.startsWith("mongodb") ? hostPath : `mongodb://${hostPath}`;
+		try {
+			const url = new URL(urlStr);
+			const hostname = url.host || hostPath;
+
+			if (!this.clients.has(hostname)) {
+				const client = new MongoClient(urlStr);
+				this.clients.set(hostname, client);
+				this.clientIds.set(hostname, id);
+			}
+		} catch (err) {
+			console.error(`Failed to parse URL for host ${hostPath}:`, err);
+			throw err;
+		}
+	}
+
+	async removeServer(name: string) {
+		await this.hostsManager.remove(name);
+		this.clients.delete(name);
+		this.clientIds.delete(name);
+	}
+}
+
+// Singleton instance
+let mongoConnections: MongoConnections | null = null;
+let initPromise: Promise<MongoConnections> | null = null;
+
+export async function getMongo(): Promise<MongoConnections> {
+	if (!mongoConnections) {
+		if (!initPromise) {
+			initPromise = (async () => {
+				mongoConnections = new MongoConnections();
+				await mongoConnections.initialize();
+				return mongoConnections;
+			})();
+		}
+		return initPromise;
+	}
+	return mongoConnections;
+}
+
+export { mongoConnections };

package/src/lib/stores/notifications.svelte.ts

@@ -0,0 +1,45 @@
+import z from "zod";
+
+interface Notification {
+	id: number;
+	message: string;
+	type: "success" | "error" | "info";
+}
+
+let notifications = $state<Notification[]>([]);
+let nextId = 1;
+
+export const notificationStore = {
+	get items() {
+		return notifications;
+	},
+
+	notify(message: string, type: "success" | "error" | "info" = "info") {
+		const id = nextId++;
+		notifications = [...notifications, { id, message, type }];
+
+		setTimeout(() => {
+			this.remove(id);
+		}, 5000);
+	},
+
+	async notifyError(message: string | unknown, fallbackMessage?: string) {
+		const finalMessage =
+			typeof message === "string"
+				? message
+				: (z.object({ message: z.string() }).safeParse(message).data?.message ??
+					z.object({ body: z.object({ message: z.string() }), status: z.number() }).safeParse(message).data?.body
+						?.message ??
+					fallbackMessage ??
+					"An unexpected error occurred");
+		this.notify(finalMessage, "error");
+	},
+
+	notifySuccess(message: string) {
+		this.notify(message, "success");
+	},
+
+	remove(id: number) {
+		notifications = notifications.filter((n) => n.id !== id);
+	},
+};

package/src/lib/types.ts

@@ -0,0 +1,56 @@
+export interface MongoDocument {
+	_id?: {
+		$type: string;
+		$value: string;
+	};
+	[key: string]: unknown;
+}
+
+export interface SearchParams {
+	query: string;
+	sort: string;
+	project: string;
+	limit: number;
+	skip: number;
+}
+
+/**
+ * Database stats as returned by the db.stats() method
+ *
+ * Type not exposed by MongoDB
+ */
+export interface DatabaseStats {
+	db: string;
+	collections: number;
+	views: number;
+	objects: number;
+	avgObjSize: number;
+	dataSize: number;
+	storageSize: number;
+	indexes: number;
+	indexSize: number;
+	totalSize: number;
+	fsUsedSize: number;
+	fsTotalSize: number;
+	ok: number;
+}
+
+export interface CollectionJSON {
+	name: string;
+	size: number;
+	dataSize: number;
+	count: number;
+	avgObjSize: number;
+	storageSize: number;
+	capped: boolean;
+	nIndexes: number;
+	totalIndexSize: number;
+	indexSizes: {
+		[name: string]: number;
+	};
+	indexes: Array<{
+		name: string;
+		key?: Record<string, number>;
+		size: number;
+	}>;
+}

package/src/lib/utils/filters.ts

@@ -0,0 +1,25 @@
+export function formatBytes(bytes: number): string {
+	if (bytes === 0) return "0 B";
+	if (bytes < 1000) return bytes + " B";
+	if (bytes < 1000000) return (bytes / 1000).toFixed(2) + " kB";
+	if (bytes < 1000000000) return (bytes / 1000000).toFixed(2) + " MB";
+	if (bytes < 1000000000000) return (bytes / 1000000000).toFixed(2) + " GB";
+	return (bytes / 1000000000000).toFixed(2) + " TB";
+}
+
+export function formatNumber(num: number): string {
+	return num.toLocaleString();
+}
+
+export function serverName(name: string): string {
+	// Extract hostname from MongoDB connection string
+	if (name.startsWith("mongodb://") || name.startsWith("mongodb+srv://")) {
+		try {
+			const url = new URL(name);
+			return url.hostname;
+		} catch {
+			return name;
+		}
+	}
+	return name;
+}

package/src/lib/utils/jsonParser.ts

@@ -0,0 +1,125 @@
+import { parseScript } from "esprima";
+import type { Expression, Node } from "estree";
+
+function buildObject(node: Node | Expression): unknown {
+	switch (node.type) {
+		case "ObjectExpression": {
+			const obj: Record<string, unknown> = {};
+			for (const prop of node.properties) {
+				let name;
+				if (prop.type === "SpreadElement") {
+					throw new Error(`Expected "Property" but received: ${prop.type}`);
+				}
+				if (prop.key.type === "Identifier") {
+					name = prop.key.name;
+				} else if (prop.key.type === "Literal") {
+					if (
+						prop.key.value instanceof RegExp ||
+						typeof prop.key.value === "bigint" ||
+						prop.key.value === false ||
+						prop.key.value === null ||
+						prop.key.value === true ||
+						prop.key.value === undefined
+					) {
+						throw new Error(`Expected "Identifier" for object key but received: ${prop.key.type}`);
+					}
+					name = prop.key.value;
+				} else {
+					throw new Error(`Expected "Identifier" but received: ${prop.key.type}`);
+				}
+
+				obj[name] = buildObject(prop.value);
+			}
+			return obj;
+		}
+
+		case "ArrayExpression": {
+			const obj: unknown[] = [];
+			for (const prop of node.elements) {
+				if (prop === null) {
+					throw new Error(`Expected "Expression" but received: ${prop}`);
+				}
+				obj.push(buildObject(prop));
+			}
+			return obj;
+		}
+
+		case "Literal": {
+			if (node.value instanceof RegExp) {
+				return {
+					$type: "RegExp",
+					$value: {
+						$pattern: node.value.source,
+						$flags: node.value.flags,
+					},
+				};
+			}
+
+			return node.value;
+		}
+
+		case "UnaryExpression": {
+			if (node.operator === "-" && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+				return -node.argument.value;
+			}
+			// const arg = buildObject(node.argument);
+			// const exp = node.prefix ? `${node.operator}${arg}` : `${arg}${node.operator}`;
+
+			// return eval(exp);
+			throw new Error(`${node.type} are not authorized`);
+		}
+
+		case "NewExpression":
+		case "CallExpression": {
+			const authorizedCalls = ["ObjectId", "Date", "RegExp"];
+			const callee = node.callee.type === "Identifier" ? node.callee.name : null;
+			if (callee && authorizedCalls.includes(callee)) {
+				if (callee === "RegExp") {
+					const [pattern, flags] = node.arguments.map((arg) => buildObject(arg));
+					return {
+						$type: "RegExp",
+						$value: {
+							$pattern: pattern,
+							$flags: flags,
+						},
+					};
+				}
+
+				return {
+					$type: callee,
+					$value: buildObject(node.arguments[0]),
+				};
+			} else {
+				throw new Error(`Unknown ${node.type}: ${callee}`);
+			}
+		}
+
+		case "Identifier": {
+			if (node.name === "undefined") {
+				return undefined;
+			}
+			throw `Unknown identifier: ${node.name}`;
+		}
+
+		default:
+			throw new Error(`Sorry but ${node.type} are not authorized`);
+	}
+}
+
+export function parseJSON(text: string): unknown {
+	const tree = parseScript(`var __JSON__ = ${text};`, {
+		tolerant: true,
+	});
+
+	const varDeclaration = tree.body[0];
+	if (varDeclaration.type !== "VariableDeclaration") {
+		throw new Error("Expected VariableDeclaration but received: " + varDeclaration.type);
+	}
+
+	const objExpression = varDeclaration.declarations[0].init;
+	if (objExpression?.type !== "ObjectExpression") {
+		throw new Error("Expected ObjectExpression but received: " + objExpression?.type);
+	}
+
+	return buildObject(objExpression);
+}

package/src/routes/+layout.server.ts

@@ -0,0 +1,7 @@
+import type { LayoutServerLoad } from "./$types";
+
+export const load: LayoutServerLoad = async () => {
+	return {
+		readOnly: process.env.MONGOKU_READ_ONLY_MODE === "true",
+	};
+};

package/src/routes/+layout.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+	import { resolve } from "$app/paths";
+	import Breadcrumbs from "$lib/components/Breadcrumbs.svelte";
+	import Notifications from "$lib/components/Notifications.svelte";
+	import "../app.css";
+
+	let { children } = $props();
+</script>
+
+<div style="min-height: 100vh">
+	<nav class="navbar px-6 py-4 flex items-center">
+		<a href={resolve("/")} class="text-2xl font-medium">Mongoku</a>
+		<Breadcrumbs />
+	</nav>
+
+	<div class="px-6 py-6 flex flex-col gap-6">
+		<Notifications />
+		{@render children()}
+	</div>
+</div>
+
+<style lang="postcss">
+	.navbar {
+		background-color: var(--color-2);
+		border-bottom: var(--border);
+	}
+</style>

package/src/routes/+page.server.ts

@@ -0,0 +1,6 @@
+import { redirect } from "@sveltejs/kit";
+import type { PageServerLoad } from "./$types";
+
+export const load: PageServerLoad = async () => {
+	redirect(307, "/servers");
+};

package/src/routes/servers/+page.server.ts

@@ -0,0 +1,53 @@
+import { getMongo } from "$lib/server/mongo";
+import type { DatabaseStats } from "$lib/types";
+import type { PageServerLoad } from "./$types";
+
+export const load: PageServerLoad = async () => {
+	const mongo = await getMongo();
+
+	const servers = mongo.listClients().map(({ name, _id, client }) => ({
+		name,
+		_id,
+		details: (async () => {
+			try {
+				const adminDb = client.db("test").admin();
+				const results = await adminDb.listDatabases();
+				const collectionsCount = await Promise.all(
+					results.databases.map(async (d) => {
+						const db = client.db(d.name);
+						const dbStats = (await db.stats()) as DatabaseStats;
+						return dbStats.collections;
+					}),
+				);
+
+				return {
+					databases: results.databases.map((d, index) => ({
+						name: d.name,
+						size: d.sizeOnDisk ?? 0,
+						collections: collectionsCount[index],
+					})),
+					size: results.totalSize ?? 0,
+				};
+			} catch (err) {
+				return {
+					error: {
+						code: err instanceof Error && "code" in err ? err.code : undefined,
+						name: err instanceof Error ? err.name : "Error",
+						message: err instanceof Error ? err.message : String(err),
+					},
+				};
+			}
+		})().catch((err) => ({
+			error: {
+				code: err instanceof Error && "code" in err ? err.code : undefined,
+				name: err instanceof Error ? err.name : "Error",
+				message: err instanceof Error ? err.message : String(err),
+			},
+		})),
+	}));
+
+	servers.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		servers,
+	};
+};