@questpie/admin 1.1.1 → 3.0.0

package/dist/server/modules/admin/index.mjs

@@ -0,0 +1,26 @@
+import { adminPlugin } from "../../plugin.mjs";
+import { savedViewsCollection } from "../admin-preferences/collections/saved-views.mjs";
+import { actionFunctions, executeAction, executeActionFn, getActionsConfig, getActionsConfigFn } from "./routes/execute-action.mjs";
+import { createPreviewFunctions, createPreviewTokenVerifier, verifyPreviewTokenDirect } from "./routes/preview.mjs";
+import { batchReactive, fieldOptions, reactiveFunctions } from "./routes/reactive.mjs";
+import { createFirstAdmin, isSetupRequired, setupFunctions } from "./routes/setup.mjs";
+import { fetchWidgetData, widgetDataFunctions } from "./routes/widget-data.mjs";
+import module_default from "./.generated/module.mjs";
+
+//#region src/server/modules/admin/index.ts
+/**
+* Admin module with codegen plugin attached.
+*
+* The `plugin` field lets `extractPluginsFromModules` auto-discover the admin
+* codegen plugin from modules.ts, eliminating the need for users to manually
+* add `plugins: [adminPlugin()]` in their questpie.config.ts.
+*/
+const adminModule = Object.assign(module_default, { plugin: adminPlugin() });
+/**
+* Admin routes — flat spread of all admin route definitions.
+* Automatically registered when adminModule is included in your app modules.
+*/
+const adminRoutes = adminModule.routes;
+
+//#endregion
+export { adminModule, adminRoutes };

package/dist/server/modules/admin/modules.mjs

@@ -0,0 +1,11 @@
+import { starterModule } from "questpie";
+
+//#region src/server/modules/admin/modules.ts
+/**
+* Admin module dependencies.
+* The admin module depends on the starter module for auth collections and assets.
+*/
+var modules_default = [starterModule];
+
+//#endregion
+export { modules_default as default };

package/dist/server/modules/admin/plugin.mjs

@@ -0,0 +1,13 @@
+import { adminPlugin } from "../../plugin.mjs";
+
+//#region src/server/modules/admin/plugin.ts
+/**
+* Admin module plugin — re-exports the admin codegen plugin so that
+* module codegen discovers it and embeds it in the generated module
+* definition. This allows `extractPluginsFromModules` to pick it up
+* automatically at root-app codegen time.
+*/
+var plugin_default = adminPlugin();
+
+//#endregion
+export { plugin_default as default };

package/dist/server/modules/admin/routes/admin-config.d.mts

@@ -0,0 +1,28 @@
+import * as questpie405 from "questpie";
+
+//#region src/server/modules/admin/routes/admin-config.d.ts
+
+/**
+ * Admin Config Functions
+ *
+ * Provides server-defined admin configuration (dashboard, sidebar,
+ * collection/global metadata) to the client via RPC.
+ *
+ * Filters results by the current user's read access.
+ *
+ * @example
+ * ```ts
+ * // Client usage
+ * const config = await client.routes.getAdminConfig({});
+ * // { dashboard: {...}, sidebar: {...}, collections: {...}, globals: {...} }
+ * ```
+ */
+/**
+ * Admin config route handlers.
+ * Registered via module routes and exposed through the fetch handler.
+ */
+declare const adminConfigFunctions: {
+  readonly getAdminConfig: questpie405.JsonRouteDefinition<Record<string, never> | undefined, any>;
+};
+//#endregion
+export { adminConfigFunctions };

package/dist/server/modules/admin/routes/admin-config.mjs

@@ -0,0 +1,552 @@
+import { introspectBlocks } from "../block/introspection.mjs";
+import { resolveDashboardCallback, resolveSidebarCallback } from "../../../proxy-factories.mjs";
+import { adminConfigDTOSchema } from "../dto/admin-config.dto.mjs";
+import { getAccessContext, getAdminConfig as getAdminConfig$1, getApp, getAppState, getCollectionState, getGlobalState } from "./route-helpers.mjs";
+import { z } from "zod";
+import { executeAccessRule, route } from "questpie";
+
+//#region src/server/modules/admin/routes/admin-config.ts
+/**
+* Admin Config Functions
+*
+* Provides server-defined admin configuration (dashboard, sidebar,
+* collection/global metadata) to the client via RPC.
+*
+* Filters results by the current user's read access.
+*
+* @example
+* ```ts
+* // Client usage
+* const config = await client.routes.getAdminConfig({});
+* // { dashboard: {...}, sidebar: {...}, collections: {...}, globals: {...} }
+* ```
+*/
+/**
+* Check if the current user has read access to a collection or global.
+* Returns true if accessible, false if denied.
+*
+* Falls back to app `defaultAccess.read` when no explicit read rule is defined.
+* If neither exists, requires session (secure by default).
+*
+* Fail-open on errors: returns true to avoid hiding content due to rule bugs.
+*/
+async function hasReadAccess(readRule, ctx) {
+	const effectiveRule = readRule ?? ctx.app?.defaultAccess?.read;
+	if (effectiveRule === true) return true;
+	if (effectiveRule === false) return false;
+	if (effectiveRule === void 0) return !!ctx.session;
+	try {
+		return await executeAccessRule(effectiveRule, {
+			app: ctx.app,
+			db: ctx.db,
+			session: ctx.session,
+			locale: ctx.locale
+		}) !== false;
+	} catch {
+		return false;
+	}
+}
+/**
+* Extract workflow metadata from a collection/global state.
+*/
+function extractWorkflowMeta(state) {
+	const versioning = state?.options?.versioning;
+	const workflow = versioning && typeof versioning === "object" ? versioning.workflow : void 0;
+	if (!workflow) return void 0;
+	const opts = workflow === true ? {} : workflow;
+	const rawStages = opts.stages;
+	let stages;
+	if (!rawStages) stages = [{ name: "draft" }, { name: "published" }];
+	else if (Array.isArray(rawStages)) stages = rawStages.map((name) => ({ name }));
+	else stages = Object.entries(rawStages).map(([name, options]) => ({
+		name,
+		label: options?.label,
+		description: options?.description,
+		transitions: options?.transitions
+	}));
+	return {
+		enabled: true,
+		initialStage: opts.initialStage ?? stages[0]?.name ?? "draft",
+		stages
+	};
+}
+/**
+* Extract admin metadata from all registered collections.
+*/
+function extractCollectionsMeta(app) {
+	const result = {};
+	const collections = app.getCollections();
+	for (const [name, collection$1] of Object.entries(collections)) {
+		const state = getCollectionState(collection$1);
+		const admin = state?.admin;
+		const workflow = extractWorkflowMeta(state);
+		if (admin) result[name] = {
+			label: admin.label,
+			description: admin.description,
+			icon: admin.icon,
+			hidden: admin.hidden,
+			group: admin.group,
+			order: admin.order,
+			...workflow ? { workflow } : {}
+		};
+		else result[name] = workflow ? { workflow } : {};
+	}
+	return result;
+}
+/**
+* Extract admin metadata from all registered globals.
+*/
+function extractGlobalsMeta(app) {
+	const result = {};
+	const globals = app.getGlobals();
+	for (const [name, global] of Object.entries(globals)) {
+		const state = getGlobalState(global);
+		const admin = state?.admin;
+		const workflow = extractWorkflowMeta(state);
+		if (admin) result[name] = {
+			label: admin.label,
+			description: admin.description,
+			icon: admin.icon,
+			hidden: admin.hidden,
+			group: admin.group,
+			order: admin.order,
+			...workflow ? { workflow } : {}
+		};
+		else result[name] = workflow ? { workflow } : {};
+	}
+	return result;
+}
+/**
+* Auto-generate a sidebar config from pre-filtered collection and global metadata.
+* Used when no explicit `.sidebar()` is configured.
+*/
+function buildAutoSidebar(collectionsMeta, globalsMeta) {
+	const ungrouped = [];
+	const grouped = {};
+	for (const [name, meta] of Object.entries(collectionsMeta)) {
+		if (meta.hidden) continue;
+		if (meta.group) {
+			if (!grouped[meta.group]) grouped[meta.group] = [];
+			grouped[meta.group].push({
+				name,
+				meta
+			});
+		} else ungrouped.push({
+			name,
+			meta
+		});
+	}
+	const sortByOrder = (a, b) => (a.meta.order ?? 0) - (b.meta.order ?? 0);
+	ungrouped.sort(sortByOrder);
+	for (const items of Object.values(grouped)) items.sort(sortByOrder);
+	const sections = [];
+	if (ungrouped.length > 0) sections.push({
+		id: "content",
+		title: { en: "Content" },
+		items: ungrouped.map(({ name, meta }) => ({
+			type: "collection",
+			collection: name,
+			label: meta.label,
+			icon: meta.icon
+		}))
+	});
+	const sortedGroupNames = Object.keys(grouped).sort();
+	for (const groupName of sortedGroupNames) {
+		const items = grouped[groupName];
+		sections.push({
+			id: `group:${groupName}`,
+			title: { en: groupName.charAt(0).toUpperCase() + groupName.slice(1) },
+			items: items.map(({ name, meta }) => ({
+				type: "collection",
+				collection: name,
+				label: meta.label,
+				icon: meta.icon
+			}))
+		});
+	}
+	const visibleGlobals = Object.entries(globalsMeta).filter(([, meta]) => !meta.hidden);
+	if (visibleGlobals.length > 0) {
+		visibleGlobals.sort(([, a], [, b]) => (a.order ?? 0) - (b.order ?? 0));
+		sections.push({
+			id: "globals",
+			title: { en: "Globals" },
+			items: visibleGlobals.map(([name, meta]) => ({
+				type: "global",
+				global: name,
+				label: meta.label,
+				icon: meta.icon
+			}))
+		});
+	}
+	return { sections };
+}
+/**
+* Filter an explicit sidebar config by accessible collections and globals.
+* Removes items referencing inaccessible collections/globals.
+* Removes empty sections after filtering.
+*/
+function filterSidebarConfig(config, accessibleCollections, accessibleGlobals) {
+	return { sections: config.sections.map((s) => ({
+		...s,
+		items: (s.items ?? []).filter((item) => {
+			const rec = item;
+			if (item.type === "collection") return accessibleCollections.has(rec.collection);
+			if (item.type === "global") return accessibleGlobals.has(rec.global);
+			return true;
+		})
+	})).filter((s) => (s.items?.length ?? 0) > 0 || (s.sections?.length ?? 0) > 0) };
+}
+/**
+* Collect all collection and global names referenced in a sidebar config.
+*/
+function collectSidebarReferences(config) {
+	const collections = /* @__PURE__ */ new Set();
+	const globals = /* @__PURE__ */ new Set();
+	function collectFromSection(section) {
+		for (const item of section.items ?? []) {
+			const rec = item;
+			if (item.type === "collection") collections.add(rec.collection);
+			else if (item.type === "global") globals.add(rec.global);
+		}
+		for (const subSection of section.sections ?? []) collectFromSection(subSection);
+	}
+	for (const section of config.sections) collectFromSection(section);
+	return {
+		collections,
+		globals
+	};
+}
+/**
+* Normalize sidebar/dashboard state from instance.state.
+* The state can be:
+* - An array of SidebarContribution[] (new composable pattern)
+* - A single SidebarContribution or SidebarCallback (legacy or config-level)
+* - A ServerSidebarConfig (old builder pattern from .sidebar() method)
+*
+* Returns a normalized array of contributions.
+*/
+function normalizeSidebarContributions(raw) {
+	if (!raw) return [];
+	if (Array.isArray(raw)) {
+		const result = [];
+		for (const item of raw) {
+			const resolved$1 = resolveSidebarCallback(item);
+			if (resolved$1) result.push(resolved$1);
+		}
+		return result;
+	}
+	const resolved = resolveSidebarCallback(raw);
+	return resolved ? [resolved] : [];
+}
+function normalizeDashboardContributions(raw) {
+	if (!raw) return [];
+	if (Array.isArray(raw)) {
+		const result = [];
+		for (const item of raw) {
+			const resolved$1 = resolveDashboardCallback(item);
+			if (resolved$1) result.push(resolved$1);
+		}
+		return result;
+	}
+	const resolved = resolveDashboardCallback(raw);
+	return resolved ? [resolved] : [];
+}
+/**
+* Merge SidebarContribution[] into a ServerSidebarConfig.
+*
+* Rules (§5.8.3):
+* - Sections: deduplicated by id. Later contribution wins for title/icon/collapsible.
+* - Items: grouped by sectionId. Appended in module resolution order.
+*   Items with `position: "start"` are prepended to the section.
+* - Sections appear in the order they were first defined.
+*/
+function mergeSidebarContributions(contributions) {
+	const sectionOrder = [];
+	const sectionDefs = /* @__PURE__ */ new Map();
+	const sectionItems = /* @__PURE__ */ new Map();
+	for (const contrib of contributions) {
+		if (contrib.sections) for (const sec of contrib.sections) {
+			const existingIdx = sectionOrder.indexOf(sec.id);
+			if (existingIdx !== -1) sectionOrder.splice(existingIdx, 1);
+			sectionOrder.push(sec.id);
+			sectionDefs.set(sec.id, {
+				title: sec.title ?? sectionDefs.get(sec.id)?.title,
+				icon: sec.icon ?? sectionDefs.get(sec.id)?.icon,
+				collapsible: sec.collapsible ?? sectionDefs.get(sec.id)?.collapsible
+			});
+		}
+		if (contrib.items) for (const item of contrib.items) {
+			const sid = item.sectionId;
+			if (!sectionItems.has(sid)) sectionItems.set(sid, []);
+			const items = sectionItems.get(sid) ?? [];
+			if (item.position === "start") items.unshift(item);
+			else items.push(item);
+			sectionItems.set(sid, items);
+			if (!sectionDefs.has(sid)) {
+				sectionOrder.push(sid);
+				sectionDefs.set(sid, {});
+			}
+		}
+	}
+	const sections = [];
+	for (const sectionId of sectionOrder) {
+		const def = sectionDefs.get(sectionId);
+		const items = sectionItems.get(sectionId) ?? [];
+		sections.push({
+			id: sectionId,
+			title: def?.title,
+			icon: def?.icon,
+			collapsible: def?.collapsible,
+			items: items.map(({ sectionId: _sid, position: _pos, ...rest }) => rest)
+		});
+	}
+	return { sections };
+}
+/**
+* Merge DashboardContribution[] into a ServerDashboardConfig.
+*
+* Rules (§5.8.3):
+* - Metadata (title, description, columns, realtime): last non-undefined wins.
+* - Actions: concatenated from all contributions.
+* - Sections: deduplicated by id. Later wins for label/layout/columns.
+* - Items: grouped by sectionId. Appended in module resolution order.
+*   Items with `position: "start"` are prepended.
+*/
+function mergeDashboardContributions(contributions) {
+	let title;
+	let description;
+	let columns;
+	let realtime;
+	const allActions = [];
+	const sectionOrder = [];
+	const sectionDefs = /* @__PURE__ */ new Map();
+	const sectionItems = /* @__PURE__ */ new Map();
+	for (const contrib of contributions) {
+		if (contrib.title !== void 0) title = contrib.title;
+		if (contrib.description !== void 0) description = contrib.description;
+		if (contrib.columns !== void 0) columns = contrib.columns;
+		if (contrib.realtime !== void 0) realtime = contrib.realtime;
+		if (contrib.actions) allActions.push(...contrib.actions);
+		if (contrib.sections) for (const sec of contrib.sections) {
+			const existingIdx = sectionOrder.indexOf(sec.id);
+			if (existingIdx !== -1) sectionOrder.splice(existingIdx, 1);
+			sectionOrder.push(sec.id);
+			sectionDefs.set(sec.id, {
+				label: sec.label ?? sectionDefs.get(sec.id)?.label,
+				layout: sec.layout ?? sectionDefs.get(sec.id)?.layout,
+				columns: sec.columns ?? sectionDefs.get(sec.id)?.columns
+			});
+		}
+		if (contrib.items) for (const item of contrib.items) {
+			const sid = item.sectionId;
+			if (!sectionItems.has(sid)) sectionItems.set(sid, []);
+			const items = sectionItems.get(sid) ?? [];
+			if (item.position === "start") items.unshift(item);
+			else items.push(item);
+			sectionItems.set(sid, items);
+			if (!sectionDefs.has(sid)) {
+				sectionOrder.push(sid);
+				sectionDefs.set(sid, {});
+			}
+		}
+	}
+	const dashboardItems = [];
+	for (const sectionId of sectionOrder) {
+		const def = sectionDefs.get(sectionId);
+		const items = sectionItems.get(sectionId) ?? [];
+		if (items.length > 0 || def?.label) dashboardItems.push({
+			type: "section",
+			label: def?.label,
+			layout: def?.layout ?? "grid",
+			columns: def?.columns,
+			items: items.map(({ sectionId: _sid, position: _pos, ...rest }) => rest)
+		});
+	}
+	return {
+		title,
+		description,
+		columns,
+		realtime,
+		actions: allActions.length > 0 ? allActions : void 0,
+		items: dashboardItems.length > 0 ? dashboardItems : void 0
+	};
+}
+/**
+* Check whether a state value looks like legacy ServerSidebarConfig
+* (has .sections array directly) vs contribution-based (array of contributions).
+*/
+function isLegacySidebarConfig(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const obj = value;
+	if (Array.isArray(obj.sections) && Array.isArray(obj.items)) return false;
+	return Array.isArray(obj.sections);
+}
+/**
+* Check whether a state value looks like legacy ServerDashboardConfig
+* (has .items or .title directly) vs contribution-based.
+*/
+function isLegacyDashboardConfig(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const obj = value;
+	if (Array.isArray(obj.sections) && Array.isArray(obj.items)) return false;
+	return "items" in obj || "title" in obj;
+}
+/**
+* Auto-assign IDs to widgets that don't have one.
+* Needed for fetchWidgetData lookup by widget ID.
+*/
+function assignWidgetIds(items) {
+	let counter = 0;
+	function walk(items$1) {
+		for (const item of items$1) {
+			const rec = item;
+			if (item.type === "section") walk(rec.items || []);
+			else if (item.type === "tabs") for (const tab of rec.tabs || []) walk(tab.items || []);
+			else if (!rec.id) rec.id = `__auto_${item.type}_${counter++}`;
+		}
+	}
+	walk(items);
+}
+/**
+* Process dashboard items: evaluate access, strip non-serializable props,
+* mark hasLoader, and filter by collection access.
+*/
+async function processDashboardItems(items, accessibleCollections, accessCtx) {
+	const result = [];
+	for (const item of items) {
+		const rec = item;
+		if (item.type === "section") {
+			const filtered = await processDashboardItems(rec.items || [], accessibleCollections, accessCtx);
+			if (filtered.length > 0) result.push({
+				...item,
+				items: filtered
+			});
+			continue;
+		}
+		if (item.type === "tabs") {
+			const rawTabs = rec.tabs || [];
+			const tabs = await Promise.all(rawTabs.map(async (tab) => {
+				const filtered = await processDashboardItems(tab.items || [], accessibleCollections, accessCtx);
+				return {
+					...tab,
+					items: filtered
+				};
+			}));
+			result.push({
+				...item,
+				tabs
+			});
+			continue;
+		}
+		const widget = rec;
+		if (widget.access !== void 0) {
+			if ((typeof widget.access === "function" ? await widget.access({
+				app: accessCtx.app,
+				db: accessCtx.db,
+				session: accessCtx.session,
+				locale: accessCtx.locale
+			}) : widget.access) === false) continue;
+		}
+		if (widget.collection && !accessibleCollections.has(widget.collection)) continue;
+		if (widget.type === "quickActions") {
+			const actions = (widget.actions || []).filter((action) => {
+				if (action.action?.type === "create") return accessibleCollections.has(action.action.collection);
+				return true;
+			});
+			const { loader: loader$1, access: access$1, ...serializable$1 } = widget;
+			result.push({
+				...serializable$1,
+				actions
+			});
+			continue;
+		}
+		const { loader, access, filterFn, ...serializable } = widget;
+		if (loader) serializable.hasLoader = true;
+		if (serializable.label && !serializable.title) serializable.title = serializable.label;
+		result.push(serializable);
+	}
+	return result;
+}
+const getAdminConfigSchema = z.object({}).optional();
+const getAdminConfigOutputSchema = adminConfigDTOSchema;
+/**
+* Get admin configuration including dashboard, sidebar, blocks,
+* and collection/global metadata.
+*
+* Filters all results by the current user's read access rules.
+*
+* @example
+* ```ts
+* // In your app
+* const app = runtimeConfig({
+*   modules: [adminModule],
+*   dashboard: ({ d }) => d.dashboard({
+*     title: { en: "Dashboard" },
+*     items: [...],
+*   }))
+*   .sidebar(({ s }) => s.sidebar({
+*     sections: [...],
+*   }))
+*   .build({ ... });
+*
+* // Client fetches config
+* const config = await client.routes.getAdminConfig({});
+* ```
+*/
+const getAdminConfig = route().post().schema(getAdminConfigSchema).outputSchema(getAdminConfigOutputSchema).handler(async (ctx) => {
+	const app = getApp(ctx);
+	const appState = getAppState(app);
+	const adminCfg = getAdminConfig$1(app);
+	const accessCtx = getAccessContext(ctx);
+	const collections = app.getCollections();
+	const globals = app.getGlobals();
+	const [accessibleCollections, accessibleGlobals] = await Promise.all([Promise.all(Object.entries(collections).map(async ([name, col]) => await hasReadAccess(getCollectionState(col).access?.read, accessCtx) ? name : null)).then((names) => new Set(names.filter(Boolean))), Promise.all(Object.entries(globals).map(async ([name, g]) => await hasReadAccess(getGlobalState(g).access?.read, accessCtx) ? name : null)).then((names) => new Set(names.filter(Boolean)))]);
+	const allCollectionsMeta = extractCollectionsMeta(app);
+	const allGlobalsMeta = extractGlobalsMeta(app);
+	const filteredCollectionsMeta = Object.fromEntries(Object.entries(allCollectionsMeta).filter(([n]) => accessibleCollections.has(n)));
+	const filteredGlobalsMeta = Object.fromEntries(Object.entries(allGlobalsMeta).filter(([n]) => accessibleGlobals.has(n)));
+	const response = {};
+	const uploadCollections = Object.entries(collections).filter(([name, collection$1]) => accessibleCollections.has(name) && Boolean(getCollectionState(collection$1).upload)).map(([name]) => name);
+	response.uploads = {
+		collections: uploadCollections,
+		defaultCollection: uploadCollections.length === 1 ? uploadCollections[0] : void 0
+	};
+	if (adminCfg.branding) response.branding = adminCfg.branding;
+	if (adminCfg.dashboard) {
+		let dashboard;
+		if (isLegacyDashboardConfig(adminCfg.dashboard)) dashboard = adminCfg.dashboard;
+		else dashboard = mergeDashboardContributions(normalizeDashboardContributions(adminCfg.dashboard));
+		if (dashboard.items) assignWidgetIds(dashboard.items);
+		response.dashboard = {
+			...dashboard,
+			items: dashboard.items ? await processDashboardItems(dashboard.items, accessibleCollections, accessCtx) : void 0
+		};
+	}
+	if (adminCfg.sidebar) {
+		let sidebarConfig;
+		if (isLegacySidebarConfig(adminCfg.sidebar)) sidebarConfig = adminCfg.sidebar;
+		else sidebarConfig = mergeSidebarContributions(normalizeSidebarContributions(adminCfg.sidebar));
+		const filteredSidebar = filterSidebarConfig(sidebarConfig, accessibleCollections, accessibleGlobals);
+		const referenced = collectSidebarReferences(sidebarConfig);
+		const unlistedSidebar = buildAutoSidebar(Object.fromEntries(Object.entries(filteredCollectionsMeta).filter(([name, meta]) => !referenced.collections.has(name) && !meta.hidden)), Object.fromEntries(Object.entries(filteredGlobalsMeta).filter(([name, meta]) => !referenced.globals.has(name) && !meta.hidden)));
+		const mergedSections = [...filteredSidebar.sections];
+		for (const unlistedSection of unlistedSidebar.sections) {
+			const existing = mergedSections.find((s) => s.id === unlistedSection.id);
+			if (existing) existing.items = [...existing.items ?? [], ...unlistedSection.items ?? []];
+			else mergedSections.push(unlistedSection);
+		}
+		response.sidebar = { sections: mergedSections };
+	} else response.sidebar = buildAutoSidebar(filteredCollectionsMeta, filteredGlobalsMeta);
+	if (appState.blocks && Object.keys(appState.blocks).length > 0) response.blocks = introspectBlocks(appState.blocks);
+	response.collections = filteredCollectionsMeta;
+	response.globals = filteredGlobalsMeta;
+	return response;
+});
+/**
+* Admin config route handlers.
+* Registered via module routes and exposed through the fetch handler.
+*/
+const adminConfigFunctions = { getAdminConfig };
+
+//#endregion
+export { adminConfigFunctions };