mongoku 2.9.2 → 2.10.0-compat

package/src/lib/server/mongo.ts

@@ -1,9 +1,10 @@
 import { env } from "$env/dynamic/private";
 import { logger } from "$lib/server/logger";
-import type { CollectionJSON, CollectionMappings, Mappings } from "$lib/types";
+import type { CollectionJSON, CollectionMappings, Mappings, ShardingInfo } from "$lib/types";
+import type { ShardKey } from "$lib/utils/shardKey";
 import { resolveSrv } from "dns/promises";
 import { MongoClient, ReadPreference, type Collection } from "mongodb";
-import { URL } from "url";
+import { buildDirectConnectionUri, mongoHostKey, parseMongoUri } from "./connectionString";
 import { HostsManager } from "./HostsManager";
 
 export async function getCollectionJson(
@@ -95,33 +96,29 @@ export async function getCollectionJson(
  * Handles both mongodb:// and mongodb+srv:// formats
  */
 export async function extractNodesFromConnectionString(connectionString: string): Promise<string[]> {
-	const url = new URL(connectionString);
+	const parsed = parseMongoUri(connectionString);
 
-	if (url.protocol === "mongodb+srv:") {
-		// For SRV, resolve DNS records
-		const hostname = url.hostname;
+	if (parsed.protocol === "mongodb+srv:") {
+		// For SRV, resolve DNS records (a single hostname, no port)
+		const hostname = parsed.hosts[0]?.split(":")[0];
+		if (!hostname) {
+			throw new Error("No hostname found in SRV connection string");
+		}
 		const srvRecords = await resolveSrv(`_mongodb._tcp.${hostname}`);
 		return srvRecords
 			.sort((a, b) => a.priority - b.priority || b.weight - a.weight)
 			.map((record) => `${record.name}:${record.port}`)
 			.sort();
 	}
-	if (url.protocol === "mongodb:") {
-		// For standard mongodb://, extract hosts from the connection string
-		// Format: mongodb://[username:password@]host1[:port1][,host2[:port2],...]/[database][?options]
-		const hostsString = url.host;
-		if (!hostsString) {
+	if (parsed.protocol === "mongodb:") {
+		// For standard mongodb://, the hosts are the comma-separated list, e.g.
+		// mongodb://[user:pass@]host1[:port1][,host2[:port2],...]/[db][?options]
+		if (parsed.hosts.length === 0) {
 			throw new Error("No hosts found in connection string");
 		}
-
-		// Split by comma to get all hosts and sort lexically
-		return hostsString
-			.split(",")
-			.map((host) => host.trim())
-			.filter((host) => host.length > 0)
-			.sort();
+		return [...parsed.hosts].sort();
 	}
-	throw new TypeError(`Unsupported protocol: ${url.protocol}`);
+	throw new TypeError(`Unsupported protocol: ${parsed.protocol}`);
 }
 
 export type IndexKey = Record<string, 1 | -1 | string>;
@@ -250,8 +247,7 @@ class MongoConnections {
 		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;
+				const hostname = mongoHostKey(urlStr) || host.path;
 
 				if (!this.clients.has(hostname)) {
 					const client = new MongoClientWithMappings(urlStr, host._id, hostname, this.readPreference);
@@ -305,8 +301,7 @@ class MongoConnections {
 		// Add the new server client
 		const urlStr = hostPath.startsWith("mongodb") ? hostPath : `mongodb://${hostPath}`;
 		try {
-			const url = new URL(urlStr);
-			const hostname = url.host || hostPath;
+			const hostname = mongoHostKey(urlStr) || hostPath;
 
 			if (!this.clients.has(hostname)) {
 				const client = new MongoClientWithMappings(urlStr, id, hostname, this.readPreference);
@@ -371,25 +366,16 @@ class MongoConnections {
 		collection: string,
 	): Promise<Record<string, { ops: number; since: Date; host: string }>> {
 		const client = this.getClient(serverId);
-		const url = new URL(client.url);
-
-		// Build direct connection URL
-		// Keep credentials and other params, but set the host to the specific node
-		const directUrl = new URL(url.toString());
-		directUrl.protocol = "mongodb:";
-		directUrl.host = node;
-		directUrl.searchParams.set("directConnection", "true");
-
-		// Keep TLS if it was in the original URL
-		if (url.searchParams.has("tls") || url.searchParams.has("ssl") || url.protocol === "mongodb+srv:") {
-			directUrl.searchParams.set("tls", "true");
-		}
+
+		// Build a single-host direct-connection URI (multi-host safe), keeping
+		// credentials, TLS and other options from the original connection string.
+		const directUri = buildDirectConnectionUri(client.url, node);
 
 		// Create a temporary client for this specific node
 		let nodeClient: MongoClient | null = null;
 		// todo: use await using when possible
 		try {
-			nodeClient = new MongoClient(directUrl.toString());
+			nodeClient = new MongoClient(directUri);
 			await nodeClient.connect();
 
 			const coll = nodeClient.db(database).collection(collection);
@@ -413,6 +399,191 @@ class MongoConnections {
 			}
 		}
 	}
+
+	/**
+	 * Return the shard key for every sharded collection in a database, in a single
+	 * query against `config.collections`. Read-only.
+	 *
+	 * Returns a map of collectionName -> shard key. Collections that are not
+	 * sharded (or on non-sharded clusters) are simply absent from the map.
+	 * Designed to be cheap enough to call once for a whole collection list.
+	 */
+	async getDatabaseShardKeys(serverId: string, database: string): Promise<Record<string, ShardKey>> {
+		const client = this.getClient(serverId);
+		const configDb = client.db("config");
+		const result: Record<string, ShardKey> = {};
+
+		try {
+			// _id of config.collections is the namespace "db.coll".
+			// Match all namespaces in this database via a prefix regex.
+			const prefix = `${database}.`;
+			const docs = (await configDb
+				.collection("collections")
+				.find({
+					_id: { $regex: `^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` },
+				} as unknown as Record<string, unknown>)
+				.project({ _id: 1, key: 1, dropped: 1 })
+				.toArray()) as unknown as Array<{
+				_id: string;
+				key?: ShardKey;
+				dropped?: boolean;
+			}>;
+
+			for (const doc of docs) {
+				if (doc.dropped || !doc.key) {
+					continue;
+				}
+				const name = doc._id.slice(prefix.length);
+				result[name] = doc.key;
+			}
+		} catch (err) {
+			logger.error("Error reading config.collections for shard keys:", err);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Gather sharding information for a collection.
+	 *
+	 * Everything here is read-only: it reads the `config` database
+	 * (config.collections / config.chunks / config.shards) and runs `$collStats`.
+	 * On a non-sharded (standalone / replica set) deployment, the `config`
+	 * collections won't exist and we return `shardingEnabled: false`.
+	 */
+	async getShardingInfo(serverId: string, database: string, collection: string): Promise<ShardingInfo> {
+		const client = this.getClient(serverId);
+		const ns = `${database}.${collection}`;
+
+		const info: ShardingInfo = {
+			shardingEnabled: false,
+			sharded: false,
+			shardKey: null,
+			hashed: false,
+			unique: false,
+			totalChunks: 0,
+			shards: [],
+			balancerEnabled: true,
+			warning: null,
+		};
+
+		const configDb = client.db("config");
+
+		// Detect whether this is a sharded cluster at all by looking for the
+		// config.shards collection. On a plain replica set this throws / is empty.
+		let shardDocs: Array<{ _id: string; host: string }> = [];
+		try {
+			shardDocs = (await configDb.collection("shards").find({}).toArray()) as unknown as Array<{
+				_id: string;
+				host: string;
+			}>;
+		} catch (err) {
+			logger.error("Error reading config.shards (not a sharded cluster?):", err);
+			return info; // shardingEnabled stays false
+		}
+
+		if (shardDocs.length === 0) {
+			// No shards => not connected through mongos / not a sharded cluster.
+			return info;
+		}
+
+		info.shardingEnabled = true;
+
+		// Look up this collection's sharding metadata.
+		// In MongoDB the _id of config.collections is the namespace "db.coll".
+		type CollConfig = {
+			_id: string;
+			key?: Record<string, 1 | -1 | string>;
+			unique?: boolean;
+			dropped?: boolean;
+			noBalance?: boolean;
+			uuid?: unknown;
+		};
+		let collConfig: CollConfig | null = null;
+		try {
+			collConfig = (await configDb
+				.collection("collections")
+				.findOne({ _id: ns } as unknown as Record<string, unknown>)) as CollConfig | null;
+		} catch (err) {
+			logger.error("Error reading config.collections:", err);
+			info.warning = "Could not read config.collections";
+		}
+
+		// Per-shard storage/document stats from $collStats (works whether sharded or not).
+		const perShard = new Map<string, { documents: number | null; size: number | null }>();
+		try {
+			const statsResults = await client
+				.db(database)
+				.collection(collection)
+				.aggregate([{ $collStats: { storageStats: {} } }])
+				.toArray();
+			for (const stat of statsResults) {
+				const shardId = (stat.shard as string) || shardDocs[0]?._id || "unknown";
+				perShard.set(shardId, {
+					documents: (stat.storageStats?.count as number) ?? null,
+					size: (stat.storageStats?.size as number) ?? null,
+				});
+			}
+		} catch (err) {
+			logger.error("Error reading $collStats for sharding info:", err);
+		}
+
+		if (collConfig && !collConfig.dropped && collConfig.key) {
+			info.sharded = true;
+			info.shardKey = collConfig.key;
+			info.hashed = Object.values(collConfig.key).some((v) => v === "hashed");
+			info.unique = !!collConfig.unique;
+			info.balancerEnabled = !collConfig.noBalance;
+
+			// Count chunks per shard for this namespace.
+			// Newer MongoDB keys config.chunks by `uuid`, older ones by `ns`.
+			try {
+				let chunkFilter: Record<string, unknown> = { ns };
+				if (collConfig.uuid !== undefined) {
+					chunkFilter = { uuid: collConfig.uuid };
+				}
+				const chunkCounts = await configDb
+					.collection("chunks")
+					.aggregate([{ $match: chunkFilter }, { $group: { _id: "$shard", count: { $sum: 1 } } }])
+					.toArray();
+				const chunkMap = new Map<string, number>(chunkCounts.map((c) => [c._id as string, c.count as number]));
+				info.totalChunks = chunkCounts.reduce((acc, c) => acc + (c.count as number), 0);
+
+				info.shards = shardDocs.map((shard) => ({
+					shardId: shard._id,
+					host: shard.host,
+					chunks: chunkMap.get(shard._id) ?? 0,
+					documents: perShard.get(shard._id)?.documents ?? null,
+					size: perShard.get(shard._id)?.size ?? null,
+				}));
+			} catch (err) {
+				logger.error("Error reading config.chunks:", err);
+				info.warning = "Could not read chunk distribution";
+				info.shards = shardDocs.map((shard) => ({
+					shardId: shard._id,
+					host: shard.host,
+					chunks: 0,
+					documents: perShard.get(shard._id)?.documents ?? null,
+					size: perShard.get(shard._id)?.size ?? null,
+				}));
+			}
+		} else {
+			// Unsharded collection on a sharded cluster: it lives on its primary shard.
+			info.sharded = false;
+			info.shards = [...perShard.entries()].map(([shardId, stats]) => {
+				const shard = shardDocs.find((s) => s._id === shardId);
+				return {
+					shardId,
+					host: shard?.host ?? shardId,
+					chunks: 0,
+					documents: stats.documents,
+					size: stats.size,
+				};
+			});
+		}
+
+		return info;
+	}
 }
 
 // Singleton instance

package/src/lib/types.ts

@@ -57,6 +57,40 @@ export interface CollectionJSON {
 	}>;
 }
 
+/**
+ * Sharding information for a collection, gathered from the `config` database
+ * and `$collStats`. All queries are read-only.
+ */
+export interface ShardingInfo {
+	/** Whether the cluster is a sharded cluster (mongos) at all. */
+	shardingEnabled: boolean;
+	/** Whether this specific collection is sharded. */
+	sharded: boolean;
+	/** The shard key, e.g. { userId: 1, _id: "hashed" }. Null if unsharded. */
+	shardKey: Record<string, 1 | -1 | string> | null;
+	/** Whether the shard key uses hashed sharding. */
+	hashed: boolean;
+	/** Whether the collection uses unique shard key. */
+	unique: boolean;
+	/** Total number of chunks across all shards. */
+	totalChunks: number;
+	/** The list of all shards known to the cluster. */
+	shards: Array<{
+		shardId: string;
+		host: string;
+		/** Number of chunks for this collection on this shard. */
+		chunks: number;
+		/** Number of documents for this collection on this shard (from $collStats). */
+		documents: number | null;
+		/** Storage size in bytes for this collection on this shard. */
+		size: number | null;
+	}>;
+	/** Whether balancing is currently enabled for the collection (noBalance flag). */
+	balancerEnabled: boolean;
+	/** Any non-fatal error/warning encountered while gathering info. */
+	warning: string | null;
+}
+
 export const ALLOWED_AGGREGATION_STAGES = new Set([
 	"$addFields",
 	"$bucket",

package/src/lib/utils/filters.ts

@@ -1,3 +1,5 @@
+import { mongoDisplayName } from "$lib/utils/mongoUri";
+
 export function formatBytes(bytes: number): string {
 	if (bytes === 0) {
 		return "0 B";
@@ -22,14 +24,10 @@ export function formatNumber(num: number): string {
 }
 
 export function serverName(name: string): string {
-	// Extract hostname from MongoDB connection string
+	// Extract a short, friendly hostname from a MongoDB connection string.
+	// Multi-host safe (mongos / replica-set URIs won't produce giant names).
 	if (name.startsWith("mongodb://") || name.startsWith("mongodb+srv://")) {
-		try {
-			const url = new URL(name);
-			return url.hostname;
-		} catch {
-			return name;
-		}
+		return mongoDisplayName(name);
 	}
 	return name;
 }

package/src/lib/utils/mongoUri.ts

@@ -0,0 +1,164 @@
+/**
+ * Isomorphic helpers for parsing MongoDB connection strings (safe on both
+ * client and server — pure string operations, no node-only imports).
+ *
+ * The WHATWG `URL` class cannot parse multi-host MongoDB URIs like
+ *   mongodb://user:pass@hostA:27017,hostB:27017,hostC:27017/db?replicaSet=rs0
+ * because the commas in the authority make it throw `TypeError: Invalid URL`.
+ * These helpers understand the comma-separated host list that MongoDB allows.
+ *
+ * Reference grammar:
+ *   mongodb://[username:password@]host1[:port1][,host2[:port2],...][/[db][?opts]]
+ *   mongodb+srv://[username:password@]host[/[db][?opts]]   (single host, no port)
+ */
+
+export interface ParsedMongoUri {
+	/** "mongodb:" or "mongodb+srv:" */
+	protocol: string;
+	username: string;
+	password: string;
+	/** The raw comma-joined host list, e.g. "a:27017,b:27017". */
+	hostsRaw: string;
+	/** Individual hosts, each possibly "host:port". */
+	hosts: string[];
+	/** Path after the hosts, including leading "/" if present (db name etc.). */
+	pathname: string;
+	/** Query string without the leading "?", or "". */
+	search: string;
+}
+
+/**
+ * Parse a MongoDB connection string into its parts, tolerating multi-host URIs.
+ * Throws a TypeError for strings that don't start with a mongodb scheme.
+ */
+export function parseMongoUri(connectionString: string): ParsedMongoUri {
+	const schemeMatch = connectionString.match(/^(mongodb(?:\+srv)?):\/\//);
+	if (!schemeMatch) {
+		throw new TypeError(`Unsupported MongoDB connection string: ${connectionString}`);
+	}
+	const protocol = `${schemeMatch[1]}:`;
+	const rest = connectionString.slice(schemeMatch[0].length);
+
+	// Authority ends at the first "/" (path), or end of string.
+	const afterAuthDelimiter = rest.indexOf("/");
+	const authorityEnd = afterAuthDelimiter === -1 ? rest.length : afterAuthDelimiter;
+	const authority = rest.slice(0, authorityEnd);
+	const tail = rest.slice(authorityEnd); // starts with "/" or ""
+
+	let credentials = "";
+	let hostsRaw = authority;
+	const atIndex = authority.lastIndexOf("@");
+	if (atIndex !== -1) {
+		credentials = authority.slice(0, atIndex);
+		hostsRaw = authority.slice(atIndex + 1);
+	}
+
+	let username = "";
+	let password = "";
+	if (credentials) {
+		const colon = credentials.indexOf(":");
+		if (colon === -1) {
+			username = credentials;
+		} else {
+			username = credentials.slice(0, colon);
+			password = credentials.slice(colon + 1);
+		}
+	}
+
+	// Split pathname and query from the tail.
+	const queryIndex = tail.indexOf("?");
+	const pathname = queryIndex === -1 ? tail : tail.slice(0, queryIndex);
+	const search = queryIndex === -1 ? "" : tail.slice(queryIndex + 1);
+
+	const hosts = hostsRaw
+		.split(",")
+		.map((h) => h.trim())
+		.filter((h) => h.length > 0);
+
+	return { protocol, username, password, hostsRaw, hosts, pathname, search };
+}
+
+/**
+ * A stable key identifying a server connection, derived from its host list.
+ * Equivalent to the old `new URL(uri).host` but multi-host safe.
+ */
+export function mongoHostKey(connectionString: string): string {
+	return parseMongoUri(connectionString).hostsRaw;
+}
+
+/**
+ * Produce a short, human-friendly display name for a connection string.
+ *
+ * Strips credentials, ports, query options and the db path, and for multi-host
+ * URIs collapses the comma list to the shared hostname (when the hosts only
+ * differ by a leading "<something>-N." prefix) so we don't render giant names.
+ * Returns the input unchanged if it isn't a mongodb URI.
+ */
+export function mongoDisplayName(connectionString: string): string {
+	let parsed: ParsedMongoUri;
+	try {
+		parsed = parseMongoUri(connectionString);
+	} catch {
+		return connectionString;
+	}
+
+	// Hostnames without ports.
+	const hostnames = parsed.hosts.map((h) => stripPort(h)).filter((h) => h.length > 0);
+	if (hostnames.length === 0) {
+		return connectionString;
+	}
+	if (hostnames.length === 1) {
+		return hostnames[0];
+	}
+
+	// Multiple hosts (e.g. a mongos/replica-set list). If they share a common
+	// domain suffix, show that with a count; otherwise just the first + count.
+	const suffix = commonDomainSuffix(hostnames);
+	if (suffix) {
+		return `${suffix} (${hostnames.length} hosts)`;
+	}
+	return `${hostnames[0]} (+${hostnames.length - 1})`;
+}
+
+function stripPort(host: string): string {
+	// Don't strip ports off IPv6 ("[::1]:27017") — keep it simple: only strip a
+	// trailing ":<digits>" when there's a single colon (hostname:port).
+	const lastColon = host.lastIndexOf(":");
+	if (lastColon === -1) {
+		return host;
+	}
+	const maybePort = host.slice(lastColon + 1);
+	if (/^\d+$/.test(maybePort) && !host.slice(0, lastColon).includes(":")) {
+		return host.slice(0, lastColon);
+	}
+	return host;
+}
+
+/**
+ * Given hosts like
+ *   mongodb-mongos-0.moonlanding-bucket-prod.mongodb.internal
+ *   mongodb-mongos-1.moonlanding-bucket-prod.mongodb.internal
+ * return the shared part after the first differing label, e.g.
+ *   moonlanding-bucket-prod.mongodb.internal
+ * Returns "" if there's no meaningful shared suffix.
+ */
+function commonDomainSuffix(hostnames: string[]): string {
+	const split = hostnames.map((h) => h.split("."));
+	const minLen = Math.min(...split.map((s) => s.length));
+	let shared = 0;
+	for (let i = 1; i <= minLen; i++) {
+		const labels = split.map((s) => s[s.length - i]);
+		if (labels.every((l) => l === labels[0])) {
+			shared = i;
+		} else {
+			break;
+		}
+	}
+	// Require at least 2 shared labels — a lone TLD ("com") isn't a useful name.
+	if (shared < 2 || shared === minLen) {
+		// No meaningful shared suffix, or the hosts are identical.
+		return shared === minLen ? hostnames[0] : "";
+	}
+	const labels = split[0];
+	return labels.slice(labels.length - shared).join(".");
+}

package/src/lib/utils/shardKey.ts

@@ -0,0 +1,16 @@
+export type ShardKey = Record<string, 1 | -1 | string>;
+
+/**
+ * Render a shard key into a compact human-readable string.
+ * e.g. { userId: 1, _id: "hashed" } -> "userId: ↑, _id: hashed"
+ */
+export function formatShardKey(key: ShardKey): string {
+	return Object.entries(key)
+		.map(([field, dir]) => {
+			if (dir === "hashed") {
+				return `${field}: hashed`;
+			}
+			return `${field}: ${dir === 1 ? "↑" : dir === -1 ? "↓" : dir}`;
+		})
+		.join(", ");
+}

package/src/routes/servers/+page.svelte

@@ -137,7 +137,7 @@
 										{serverName(server.name)}
 									</span>
 								{:else}
-									<a href={resolve(`/servers/${encodeURIComponent(serverName(server.name))}/databases`)}>
+									<a href={resolve(`/servers/${encodeURIComponent(server.name)}/databases`)}>
 										{serverName(server.name)}
 									</a>
 								{/if}

package/src/routes/servers/[server]/databases/[database]/collections/+page.server.ts

@@ -13,7 +13,12 @@ export const load: PageServerLoad = async ({ params }) => {
 		details: getCollectionJson(db.collection(c.name), c.type).catch(() => null),
 	}));
 
+	// Single read against config.collections for the whole DB. Streamed so the
+	// table renders immediately and the badges fill in when this resolves.
+	const shardKeys = mongo.getDatabaseShardKeys(params.server, params.database).catch(() => ({}));
+
 	return {
 		collections: collectionsWithDetails,
+		shardKeys,
 	};
 };

package/src/routes/servers/[server]/databases/[database]/collections/+page.svelte

@@ -4,15 +4,41 @@
 	import { resolve } from "$app/paths";
 	import Modal from "$lib/components/Modal.svelte";
 	import Panel from "$lib/components/Panel.svelte";
+	import ShardBadge from "$lib/components/ShardBadge.svelte";
 	import TooltipTable from "$lib/components/TooltipTable.svelte";
 	import { notificationStore } from "$lib/stores/notifications.svelte";
 	import { formatBytes, formatNumber } from "$lib/utils/filters";
+	import type { ShardKey } from "$lib/utils/shardKey";
 	import type { PageData } from "./$types";
 
 	let { data }: { data: PageData } = $props();
 
 	type Collection = PageData["collections"][number];
 
+	// Resolve the streamed shard keys, guarding against out-of-order responses:
+	// when navigating between databases, a slow previous request must not
+	// overwrite the current one. We key on the promise identity (reassigned by
+	// the loader on each navigation) and drop any result from a stale promise.
+	let shardKeys = $state<Record<string, ShardKey>>({});
+
+	$effect(() => {
+		const promise = data.shardKeys;
+		// Reset immediately so badges from the previous database disappear while
+		// the new request is in flight.
+		shardKeys = {};
+		let cancelled = false;
+		// Silently ignore failures (e.g. no read access to the config database):
+		// the load already degrades to {}, and this just leaves badges off.
+		promise.then((keys) => {
+			if (!cancelled) {
+				shardKeys = keys;
+			}
+		});
+		return () => {
+			cancelled = true;
+		};
+	});
+
 	let showDropModal = $state(false);
 	let collectionToDrop = $state<Collection | null>(null);
 	let isDropping = $state(false);
@@ -67,15 +93,27 @@
 				{#each data.collections as collection (collection.name)}
 					<tr class="group">
 						<td>
-							<a
-								href={resolve(
-									`/servers/${encodeURIComponent(data.server)}/databases/${encodeURIComponent(
-										data.database,
-									)}/collections/${encodeURIComponent(collection.name)}/documents`,
-								)}
-							>
-								{collection.name}
-							</a>
+							<div class="flex items-center gap-2">
+								<a
+									href={resolve(
+										`/servers/${encodeURIComponent(data.server)}/databases/${encodeURIComponent(
+											data.database,
+										)}/collections/${encodeURIComponent(collection.name)}/documents`,
+									)}
+								>
+									{collection.name}
+								</a>
+								{#if shardKeys[collection.name]}
+									<ShardBadge
+										shardKey={shardKeys[collection.name]}
+										href={resolve(
+											`/servers/${encodeURIComponent(data.server)}/databases/${encodeURIComponent(
+												data.database,
+											)}/collections/${encodeURIComponent(collection.name)}/sharding`,
+										)}
+									/>
+								{/if}
+							</div>
 						</td>
 						<td>
 							{#await collection.details}

package/src/routes/servers/[server]/databases/[database]/collections/[collection]/+layout.ts

@@ -1,6 +1,9 @@
+import { COLLECTION_CATEGORIES } from "$lib/collectionCategories";
+
 export const load = async (event) => {
 	return {
 		collection: event.params.collection,
+		categories: COLLECTION_CATEGORIES,
 		breadcrumbs: [
 			...(await event.parent()).breadcrumbs,
 			{ label: event.params.collection, path: `/${event.params.collection}/documents` },