@questpie/admin 1.1.1 → 3.0.0

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

@@ -0,0 +1,102 @@
+import { z } from "zod";
+
+//#region src/server/modules/admin/dto/admin-config.dto.ts
+/**
+* Admin Config DTO Types
+*
+* Typed interfaces for the admin config response shapes returned by
+* the getAdminConfig route. These define the discriminated/unified
+* shape that the admin client consumes.
+*
+* These types are the "wire format" — what the client receives.
+* They mirror the server augmentation types but are pure data
+* (no functions, no callbacks, no non-serializable fields).
+*/
+const componentReferenceSchema = z.object({
+	type: z.string(),
+	props: z.record(z.string(), z.any()).optional()
+});
+const sidebarItemSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("collection"),
+		collection: z.string(),
+		label: z.record(z.string(), z.string()).optional(),
+		icon: componentReferenceSchema.optional()
+	}),
+	z.object({
+		type: z.literal("global"),
+		global: z.string(),
+		label: z.record(z.string(), z.string()).optional(),
+		icon: componentReferenceSchema.optional()
+	}),
+	z.object({
+		type: z.literal("page"),
+		pageId: z.string(),
+		label: z.record(z.string(), z.string()).optional(),
+		icon: componentReferenceSchema.optional()
+	}),
+	z.object({
+		type: z.literal("link"),
+		href: z.string(),
+		label: z.record(z.string(), z.string()),
+		icon: componentReferenceSchema.optional(),
+		external: z.boolean().optional()
+	}),
+	z.object({ type: z.literal("divider") })
+]);
+const sidebarSectionSchema = z.lazy(() => z.object({
+	id: z.string(),
+	title: z.record(z.string(), z.string()).optional(),
+	icon: componentReferenceSchema.optional(),
+	collapsible: z.boolean().optional(),
+	items: z.array(sidebarItemSchema).optional(),
+	sections: z.array(sidebarSectionSchema).optional()
+}));
+const sidebarConfigSchema = z.object({ sections: z.array(sidebarSectionSchema) });
+const workflowMetaSchema = z.object({
+	enabled: z.boolean(),
+	initialStage: z.string(),
+	stages: z.array(z.object({
+		name: z.string(),
+		label: z.string().optional(),
+		description: z.string().optional(),
+		transitions: z.array(z.string()).optional()
+	}))
+});
+const collectionMetaSchema = z.object({
+	label: z.record(z.string(), z.string()).optional(),
+	description: z.record(z.string(), z.string()).optional(),
+	icon: componentReferenceSchema.optional(),
+	hidden: z.boolean().optional(),
+	group: z.string().optional(),
+	order: z.number().optional(),
+	workflow: workflowMetaSchema.optional()
+});
+const uploadsConfigSchema = z.object({
+	collections: z.array(z.string()),
+	defaultCollection: z.string().optional()
+});
+const dashboardConfigSchema = z.object({
+	title: z.record(z.string(), z.string()).optional(),
+	description: z.record(z.string(), z.string()).optional(),
+	columns: z.number().optional(),
+	realtime: z.boolean().optional(),
+	actions: z.array(z.any()).optional(),
+	items: z.array(z.record(z.string(), z.any())).optional()
+});
+/**
+* Zod schema for the complete AdminConfigDTO.
+* Can be used as the outputSchema for the getAdminConfig route.
+*/
+const adminConfigDTOSchema = z.object({
+	dashboard: dashboardConfigSchema.optional(),
+	sidebar: sidebarConfigSchema.optional(),
+	branding: z.record(z.string(), z.any()).optional(),
+	blocks: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+	collections: z.record(z.string(), collectionMetaSchema).optional(),
+	globals: z.record(z.string(), collectionMetaSchema).optional(),
+	uploads: uploadsConfigSchema.optional()
+});
+
+//#endregion
+export { adminConfigDTOSchema };

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

@@ -0,0 +1,172 @@
+import { CollectionBuilder } from "questpie";
+
+//#region src/server/modules/admin/factories.ts
+/**
+* Admin Module Factories
+*
+* Proxy-wrapped `collection()` and `global()` for use within the admin module.
+* Resolves `.admin()`, `.list()`, `.form()`, `.actions()`, `.preview()` callbacks
+* the same way the user-level generated factories.ts does.
+*
+* Without this, admin module collections that use `.set("admin", callback)` store
+* raw functions instead of resolved config objects, breaking meta extraction.
+*
+* @internal — only for admin module collections, not exported from package
+*/
+/** Create a view proxy with declarative aliases baked in. */
+function _viewProxyWithAliases(aliases) {
+	return new Proxy({}, { get: (_, prop) => (config) => ({
+		view: aliases[String(prop)] ?? String(prop),
+		...config
+	}) });
+}
+const _componentProxy = new Proxy({}, { get: (_, prop) => (...args) => ({
+	type: String(prop),
+	props: typeof args[0] === "string" ? { name: args[0] } : args[0] ?? {}
+}) });
+const _fieldRefProxy = new Proxy({}, { get: (_, prop) => String(prop) });
+/**
+* Field builder proxy for actions context.
+* Supports `f.text().required().label({...})` chaining.
+* Each method call returns a new proxy with accumulated properties.
+*/
+function _createFieldBuilderProxy() {
+	return new Proxy({}, { get: (_, prop) => {
+		if (typeof prop !== "string") return void 0;
+		return (...args) => {
+			const def = { type: prop };
+			if (Array.isArray(args[0])) def.options = args[0];
+			else if (args[0] && typeof args[0] === "object") Object.assign(def, args[0]);
+			else if (args[0] !== void 0) def.value = args[0];
+			return _chainable(def);
+		};
+	} });
+}
+function _chainable(def) {
+	return new Proxy(def, { get: (target, prop) => {
+		if (typeof prop !== "string") return Reflect.get(target, prop);
+		if (prop in target) return target[prop];
+		return (...args) => _chainable({
+			...target,
+			[prop]: args.length === 0 ? true : args[0]
+		});
+	} });
+}
+/**
+* Action proxy for actions context.
+* Supports both `a.save()` (builtin) and `a.headerAction({...})` (custom).
+*/
+const _actionBuilderProxy = new Proxy({}, { get: (_, prop) => {
+	if (typeof prop !== "string") return void 0;
+	return (...args) => {
+		if (args.length === 0) return prop;
+		return {
+			id: prop,
+			...args[0]
+		};
+	};
+} });
+const _simpleActionProxy = new Proxy({ custom: (name, config) => ({
+	id: name,
+	...config
+}) }, { get: (target, prop) => target[prop] ?? String(prop) });
+const _collExt = {
+	admin: {
+		stateKey: "admin",
+		resolve(configOrFn) {
+			if (typeof configOrFn === "function") return configOrFn({ c: _componentProxy });
+			return configOrFn;
+		}
+	},
+	list: {
+		stateKey: "adminList",
+		resolve(configOrFn) {
+			return {
+				view: "collection-table",
+				showSearch: true,
+				showFilters: true,
+				showToolbar: true,
+				...typeof configOrFn === "function" ? configOrFn({
+					v: _viewProxyWithAliases({
+						table: "collection-table",
+						collectionTable: "collection-table"
+					}),
+					f: _fieldRefProxy,
+					a: _simpleActionProxy
+				}) : configOrFn
+			};
+		}
+	},
+	form: {
+		stateKey: "adminForm",
+		resolve(configOrFn) {
+			return {
+				view: "collection-form",
+				showMeta: true,
+				...typeof configOrFn === "function" ? configOrFn({
+					v: _viewProxyWithAliases({
+						form: "collection-form",
+						collectionForm: "collection-form"
+					}),
+					f: _fieldRefProxy
+				}) : configOrFn
+			};
+		}
+	},
+	preview: {
+		stateKey: "adminPreview",
+		resolve: (v) => v
+	},
+	actions: {
+		stateKey: "adminActions",
+		resolve(configOrFn) {
+			if (typeof configOrFn === "function") return configOrFn({
+				a: _actionBuilderProxy,
+				c: _componentProxy,
+				f: _createFieldBuilderProxy()
+			});
+			return configOrFn;
+		}
+	}
+};
+function _wrapColl(builder) {
+	return new Proxy(builder, { get(target, prop, receiver) {
+		if (typeof prop === "string" && prop in _collExt) {
+			const ext = _collExt[prop];
+			return (configOrFn) => _wrapColl(target.set(ext.stateKey, ext.resolve(configOrFn)));
+		}
+		const val = Reflect.get(target, prop, receiver);
+		if (typeof val === "function") return function(...args) {
+			const result = val.apply(target, args);
+			return result instanceof CollectionBuilder ? _wrapColl(result) : result;
+		};
+		return val;
+	} });
+}
+/**
+* Create a collection builder with admin extension methods.
+* Use this instead of importing `collection` from "questpie" in admin module collections.
+*/
+function collection$1(name) {
+	return _wrapColl(new CollectionBuilder({
+		name,
+		fields: {},
+		localized: [],
+		virtuals: void 0,
+		relations: {},
+		indexes: {},
+		title: void 0,
+		options: {},
+		hooks: {},
+		access: {},
+		searchable: void 0,
+		validation: void 0,
+		output: void 0,
+		upload: void 0,
+		fieldDefinitions: {},
+		"~questpieApp": void 0
+	}));
+}
+
+//#endregion
+export { collection$1 as collection };