@questpie/openapi 3.0.18 → 3.0.20

package/dist/server.mjs

@@ -1,1205 +1,3 @@
-import { openApiPlugin } from "./plugin.mjs";
-import { module, route } from "questpie";
-import { z } from "zod";
+import { a as openApiRoute, i as openApiModule, n as generateOpenApiSpec, o as server_default, r as openApiConfig, t as docsRoute } from "./server-DsUIkt4E.mjs";
 
-//#region src/generator/schemas.ts
-/**
-* Shared schema helpers for OpenAPI spec generation.
-* Provides $ref utilities, common schemas (pagination, errors), and Zod conversion helpers.
-*/
-/**
-* Create a $ref pointer to a component schema.
-*/
-function ref(name) {
-	return { $ref: `#/components/schemas/${name}` };
-}
-/**
-* Standard error response schema.
-*/
-function errorResponseSchema() {
-	return {
-		type: "object",
-		properties: { error: {
-			type: "object",
-			properties: {
-				code: { type: "string" },
-				message: { type: "string" },
-				details: {}
-			},
-			required: ["code", "message"]
-		} },
-		required: ["error"]
-	};
-}
-/**
-* Paginated response wrapper for a given item schema.
-*/
-function paginatedResponseSchema(itemRef) {
-	return {
-		type: "object",
-		properties: {
-			docs: {
-				type: "array",
-				items: itemRef
-			},
-			totalDocs: { type: "integer" },
-			limit: { type: "integer" },
-			page: { type: "integer" },
-			totalPages: { type: "integer" },
-			hasNextPage: { type: "boolean" },
-			hasPrevPage: { type: "boolean" },
-			nextPage: { type: ["integer", "null"] },
-			prevPage: { type: ["integer", "null"] }
-		},
-		required: [
-			"docs",
-			"totalDocs",
-			"limit",
-			"page",
-			"totalPages"
-		]
-	};
-}
-/**
-* Common query parameters for collection list endpoints.
-*/
-function listQueryParameters() {
-	return [
-		{
-			name: "limit",
-			in: "query",
-			schema: {
-				type: "integer",
-				default: 10
-			},
-			description: "Number of records to return"
-		},
-		{
-			name: "page",
-			in: "query",
-			schema: {
-				type: "integer",
-				default: 1
-			},
-			description: "Page number"
-		},
-		{
-			name: "offset",
-			in: "query",
-			schema: { type: "integer" },
-			description: "Number of records to skip"
-		},
-		{
-			name: "where",
-			in: "query",
-			schema: { type: "string" },
-			description: "Filter conditions (JSON encoded)"
-		},
-		{
-			name: "orderBy",
-			in: "query",
-			schema: { type: "string" },
-			description: "Sort configuration (JSON encoded)"
-		},
-		{
-			name: "locale",
-			in: "query",
-			schema: { type: "string" },
-			description: "Content locale"
-		},
-		stageQueryParameter()
-	];
-}
-/**
-* Common query parameters for single-record endpoints.
-*/
-function singleQueryParameters() {
-	return [{
-		name: "locale",
-		in: "query",
-		schema: { type: "string" },
-		description: "Content locale"
-	}, stageQueryParameter()];
-}
-function stageQueryParameter() {
-	return {
-		name: "stage",
-		in: "query",
-		schema: { type: "string" },
-		description: "Workflow stage"
-	};
-}
-/**
-* Standard JSON responses helper.
-*/
-function jsonResponse(schema, description = "Successful response") {
-	return {
-		"200": {
-			description,
-			content: { "application/json": { schema } }
-		},
-		"400": {
-			description: "Bad request",
-			content: { "application/json": { schema: ref("ErrorResponse") } }
-		},
-		"401": {
-			description: "Unauthorized",
-			content: { "application/json": { schema: ref("ErrorResponse") } }
-		},
-		"404": {
-			description: "Not found",
-			content: { "application/json": { schema: ref("ErrorResponse") } }
-		}
-	};
-}
-/**
-* JSON request body helper.
-*/
-function jsonRequestBody(schema, description) {
-	return {
-		description,
-		required: true,
-		content: { "application/json": { schema } }
-	};
-}
-/**
-* Safely convert a Zod schema to JSON Schema.
-* Falls back to a permissive object schema on failure.
-*/
-function zodToJsonSchema(schema) {
-	try {
-		if (schema && typeof schema === "object" && "_def" in schema) return z.toJSONSchema(schema);
-	} catch {}
-	return {
-		type: "object",
-		description: "Schema could not be generated"
-	};
-}
-/**
-* Build the base component schemas shared across all endpoints.
-*/
-function baseComponentSchemas() {
-	return {
-		ErrorResponse: errorResponseSchema(),
-		SuccessResponse: {
-			type: "object",
-			properties: { success: { type: "boolean" } },
-			required: ["success"]
-		},
-		CountResponse: {
-			type: "object",
-			properties: { count: { type: "integer" } },
-			required: ["count"]
-		},
-		DeleteManyResponse: {
-			type: "object",
-			properties: {
-				success: { type: "boolean" },
-				count: { type: "integer" }
-			},
-			required: ["success"]
-		}
-	};
-}
-
-//#endregion
-//#region src/generator/auth.ts
-/**
-* Generate OpenAPI paths for Better Auth endpoints.
-*/
-function generateAuthPaths(config) {
-	if (config.auth === false) return {
-		paths: {},
-		tags: []
-	};
-	const basePath = config.basePath ?? "/";
-	const tag = "Auth";
-	const paths = {};
-	paths[`${basePath}/auth/sign-in/email`] = { post: {
-		operationId: "auth_signInEmail",
-		summary: "Sign in with email and password",
-		tags: [tag],
-		requestBody: jsonRequestBody({
-			type: "object",
-			properties: {
-				email: {
-					type: "string",
-					format: "email"
-				},
-				password: { type: "string" }
-			},
-			required: ["email", "password"]
-		}),
-		responses: jsonResponse({
-			type: "object",
-			properties: {
-				user: { type: "object" },
-				session: { type: "object" }
-			}
-		}, "Authentication successful")
-	} };
-	paths[`${basePath}/auth/sign-up/email`] = { post: {
-		operationId: "auth_signUpEmail",
-		summary: "Sign up with email and password",
-		tags: [tag],
-		requestBody: jsonRequestBody({
-			type: "object",
-			properties: {
-				email: {
-					type: "string",
-					format: "email"
-				},
-				password: { type: "string" },
-				name: { type: "string" }
-			},
-			required: [
-				"email",
-				"password",
-				"name"
-			]
-		}),
-		responses: jsonResponse({
-			type: "object",
-			properties: {
-				user: { type: "object" },
-				session: { type: "object" }
-			}
-		}, "Registration successful")
-	} };
-	paths[`${basePath}/auth/get-session`] = { get: {
-		operationId: "auth_getSession",
-		summary: "Get current session",
-		tags: [tag],
-		responses: jsonResponse({
-			type: "object",
-			properties: {
-				user: { type: "object" },
-				session: { type: "object" }
-			}
-		}, "Current session")
-	} };
-	paths[`${basePath}/auth/sign-out`] = { post: {
-		operationId: "auth_signOut",
-		summary: "Sign out",
-		tags: [tag],
-		responses: jsonResponse({
-			type: "object",
-			properties: { success: { type: "boolean" } }
-		}, "Signed out")
-	} };
-	return {
-		paths,
-		tags: [{
-			name: tag,
-			description: "Authentication endpoints (Better Auth)"
-		}]
-	};
-}
-
-//#endregion
-//#region src/generator/collections.ts
-/**
-* Generate OpenAPI paths and component schemas for all collections.
-*/
-function generateCollectionPaths(app, config) {
-	const collections = app.getCollections();
-	const basePath = config.basePath ?? "/";
-	const excluded = new Set(config.exclude?.collections ?? []);
-	const paths = {};
-	const schemas = {};
-	const tags = [];
-	for (const [name, collection] of Object.entries(collections)) {
-		if (excluded.has(name)) continue;
-		const state = collection.state;
-		if (!state) continue;
-		const tag = `Collections: ${name}`;
-		tags.push({
-			name: tag,
-			description: `CRUD operations for ${name}`
-		});
-		const pascalName = toPascalCase$1(name);
-		const documentSchemaName = `${pascalName}Document`;
-		const insertSchemaName = `${pascalName}Insert`;
-		const updateSchemaName = `${pascalName}Update`;
-		const fieldDefinitionSchema = buildSchemaFromFieldDefinitions(state.fieldDefinitions);
-		if (state.validation?.insertSchema) try {
-			schemas[insertSchemaName] = z.toJSONSchema(state.validation.insertSchema, { unrepresentable: "any" });
-		} catch {
-			schemas[insertSchemaName] = {
-				type: "object",
-				description: `Insert schema for ${name}`
-			};
-		}
-		else if (fieldDefinitionSchema != null) schemas[insertSchemaName] = fieldDefinitionSchema.insert;
-		else schemas[insertSchemaName] = {
-			type: "object",
-			description: `Insert schema for ${name}`
-		};
-		if (state.validation?.updateSchema) try {
-			schemas[updateSchemaName] = z.toJSONSchema(state.validation.updateSchema, { unrepresentable: "any" });
-		} catch {
-			schemas[updateSchemaName] = {
-				type: "object",
-				description: `Update schema for ${name}`
-			};
-		}
-		else if (fieldDefinitionSchema != null) schemas[updateSchemaName] = fieldDefinitionSchema.update;
-		else schemas[updateSchemaName] = {
-			type: "object",
-			description: `Update schema for ${name}`
-		};
-		schemas[documentSchemaName] = buildDocumentSchema(name, state, insertSchemaName);
-		const prefix = `${basePath}/${name}`;
-		paths[prefix] = {
-			get: {
-				operationId: `${name}_find`,
-				summary: `List ${name}`,
-				tags: [tag],
-				parameters: listQueryParameters(),
-				responses: jsonResponse(paginatedResponseSchema(ref(documentSchemaName)), `Paginated list of ${name}`)
-			},
-			post: {
-				operationId: `${name}_create`,
-				summary: `Create ${name}`,
-				tags: [tag],
-				parameters: [stageQueryParameter()],
-				requestBody: jsonRequestBody(ref(insertSchemaName)),
-				responses: jsonResponse(ref(documentSchemaName), `Created ${name} record`)
-			}
-		};
-		paths[`${prefix}/count`] = { get: {
-			operationId: `${name}_count`,
-			summary: `Count ${name}`,
-			tags: [tag],
-			parameters: [{
-				name: "where",
-				in: "query",
-				schema: { type: "string" },
-				description: "Filter conditions (JSON encoded)"
-			}],
-			responses: jsonResponse(ref("CountResponse"), `Count of ${name}`)
-		} };
-		paths[`${prefix}/delete-many`] = { post: {
-			operationId: `${name}_deleteMany`,
-			summary: `Delete many ${name}`,
-			tags: [tag],
-			requestBody: jsonRequestBody({
-				type: "object",
-				properties: { where: {
-					type: "object",
-					description: "Filter conditions for records to delete"
-				} }
-			}),
-			responses: jsonResponse(ref("DeleteManyResponse"), `Delete multiple ${name} records`)
-		} };
-		if (state.upload) paths[`${prefix}/upload`] = { post: {
-			operationId: `${name}_upload`,
-			summary: `Upload file to ${name}`,
-			tags: [tag],
-			requestBody: {
-				required: true,
-				content: { "multipart/form-data": { schema: {
-					type: "object",
-					properties: { file: {
-						type: "string",
-						format: "binary"
-					} },
-					required: ["file"]
-				} } }
-			},
-			responses: jsonResponse(ref(documentSchemaName), `Uploaded file record`)
-		} };
-		paths[`${prefix}/schema`] = { get: {
-			operationId: `${name}_schema`,
-			summary: `Get ${name} introspection schema`,
-			tags: [tag],
-			responses: jsonResponse({
-				type: "object",
-				description: "Introspected collection schema"
-			}, `Introspection schema for ${name}`)
-		} };
-		paths[`${prefix}/meta`] = { get: {
-			operationId: `${name}_meta`,
-			summary: `Get ${name} metadata`,
-			tags: [tag],
-			responses: jsonResponse({
-				type: "object",
-				description: "Collection metadata"
-			}, `Metadata for ${name}`)
-		} };
-		const idParam = {
-			name: "id",
-			in: "path",
-			required: true,
-			schema: { type: "string" },
-			description: "Record ID"
-		};
-		paths[`${prefix}/{id}`] = {
-			get: {
-				operationId: `${name}_findOne`,
-				summary: `Get ${name} by ID`,
-				tags: [tag],
-				parameters: [idParam, ...singleQueryParameters()],
-				responses: jsonResponse(ref(documentSchemaName), `Single ${name} record`)
-			},
-			patch: {
-				operationId: `${name}_update`,
-				summary: `Update ${name}`,
-				tags: [tag],
-				parameters: [idParam, stageQueryParameter()],
-				requestBody: jsonRequestBody(ref(updateSchemaName)),
-				responses: jsonResponse(ref(documentSchemaName), `Updated ${name} record`)
-			},
-			delete: {
-				operationId: `${name}_delete`,
-				summary: `Delete ${name}`,
-				tags: [tag],
-				parameters: [idParam, stageQueryParameter()],
-				responses: jsonResponse(ref("SuccessResponse"), `Deleted ${name} record`)
-			}
-		};
-		if (state.options?.softDelete) paths[`${prefix}/{id}/restore`] = { post: {
-			operationId: `${name}_restore`,
-			summary: `Restore deleted ${name}`,
-			tags: [tag],
-			parameters: [idParam, stageQueryParameter()],
-			responses: jsonResponse(ref(documentSchemaName), `Restored ${name} record`)
-		} };
-		paths[`${prefix}/{id}/versions`] = { get: {
-			operationId: `${name}_findVersions`,
-			summary: `List ${name} versions`,
-			tags: [tag],
-			parameters: [
-				idParam,
-				{
-					name: "limit",
-					in: "query",
-					schema: { type: "number" },
-					description: "Maximum number of versions to return"
-				},
-				{
-					name: "offset",
-					in: "query",
-					schema: { type: "number" },
-					description: "Number of versions to skip"
-				}
-			],
-			responses: jsonResponse({
-				type: "array",
-				items: {
-					type: "object",
-					properties: {
-						id: { type: "string" },
-						versionId: { type: "string" },
-						versionNumber: { type: "number" },
-						versionOperation: { type: "string" },
-						versionUserId: { type: ["string", "null"] },
-						versionCreatedAt: {
-							type: "string",
-							format: "date-time"
-						}
-					}
-				}
-			}, `Version history for ${name}`)
-		} };
-		paths[`${prefix}/{id}/revert`] = { post: {
-			operationId: `${name}_revertToVersion`,
-			summary: `Revert ${name} to a version`,
-			tags: [tag],
-			parameters: [idParam, stageQueryParameter()],
-			requestBody: jsonRequestBody({
-				type: "object",
-				properties: {
-					version: { type: "number" },
-					versionId: { type: "string" }
-				}
-			}),
-			responses: jsonResponse(ref(documentSchemaName), `Reverted ${name} record`)
-		} };
-		const versioningOpts = state.options?.versioning;
-		if (versioningOpts && typeof versioningOpts === "object" && versioningOpts.workflow) paths[`${prefix}/{id}/transition`] = { post: {
-			operationId: `${name}_transition`,
-			summary: `Transition ${name} workflow stage`,
-			tags: [tag],
-			parameters: [idParam],
-			requestBody: jsonRequestBody({
-				type: "object",
-				required: ["stage"],
-				properties: { stage: {
-					type: "string",
-					description: "Target workflow stage"
-				} }
-			}),
-			responses: jsonResponse(ref(documentSchemaName), `Transitioned ${name} record`)
-		} };
-	}
-	return {
-		paths,
-		schemas,
-		tags
-	};
-}
-/**
-* Build a document response schema that extends the insert schema with
-* standard fields (id, timestamps).
-*/
-function buildDocumentSchema(name, state, insertSchemaName) {
-	const properties = { id: { type: "string" } };
-	if (state.options?.timestamps !== false) {
-		properties.createdAt = {
-			type: "string",
-			format: "date-time"
-		};
-		properties.updatedAt = {
-			type: "string",
-			format: "date-time"
-		};
-	}
-	if (state.options?.softDelete) properties.deletedAt = {
-		type: ["string", "null"],
-		format: "date-time"
-	};
-	return {
-		allOf: [{
-			type: "object",
-			properties,
-			required: ["id"]
-		}, ref(insertSchemaName)],
-		description: `${name} document`
-	};
-}
-function toPascalCase$1(str) {
-	return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
-}
-function buildSchemaFromFieldDefinitions(fieldDefinitions) {
-	if (!fieldDefinitions || typeof fieldDefinitions !== "object") return null;
-	const shape = {};
-	for (const [fieldName, fieldDefinition] of Object.entries(fieldDefinitions)) {
-		const fd = fieldDefinition;
-		if (typeof fd.toZodSchema !== "function") continue;
-		try {
-			const schema = fd.toZodSchema();
-			if (schema && typeof schema === "object" && "_def" in schema) shape[fieldName] = schema;
-		} catch {}
-	}
-	if (Object.keys(shape).length === 0) return null;
-	const insertSchema = z.object(shape);
-	const updateSchema = insertSchema.partial();
-	return {
-		insert: z.toJSONSchema(insertSchema, { unrepresentable: "any" }),
-		update: z.toJSONSchema(updateSchema, { unrepresentable: "any" })
-	};
-}
-
-//#endregion
-//#region src/generator/globals.ts
-/**
-* Generate OpenAPI paths and component schemas for all globals.
-*/
-function generateGlobalPaths(app, config) {
-	const globals = app.getGlobals();
-	const basePath = config.basePath ?? "/";
-	const excluded = new Set(config.exclude?.globals ?? []);
-	const paths = {};
-	const schemas = {};
-	const tags = [];
-	for (const [name, global] of Object.entries(globals)) {
-		if (excluded.has(name)) continue;
-		const state = global.state;
-		if (!state) continue;
-		const tag = `Globals: ${name}`;
-		tags.push({
-			name: tag,
-			description: `Operations for ${name} global`
-		});
-		const pascalName = toPascalCase(name);
-		const valueSchemaName = `${pascalName}Global`;
-		const updateSchemaName = `${pascalName}GlobalUpdate`;
-		const fieldDefinitionSchema = buildGlobalSchemaFromFieldDefinitions(state.fieldDefinitions);
-		if (state.validation?.updateSchema) try {
-			schemas[updateSchemaName] = z.toJSONSchema(state.validation.updateSchema, { unrepresentable: "any" });
-		} catch {
-			schemas[updateSchemaName] = {
-				type: "object",
-				description: `Update schema for ${name} global`
-			};
-		}
-		else if (fieldDefinitionSchema != null) schemas[updateSchemaName] = fieldDefinitionSchema;
-		else schemas[updateSchemaName] = {
-			type: "object",
-			description: `Update schema for ${name} global`
-		};
-		const properties = { id: { type: "string" } };
-		if (state.options?.timestamps !== false) {
-			properties.createdAt = {
-				type: "string",
-				format: "date-time"
-			};
-			properties.updatedAt = {
-				type: "string",
-				format: "date-time"
-			};
-		}
-		schemas[valueSchemaName] = {
-			allOf: [{
-				type: "object",
-				properties,
-				required: ["id"]
-			}, ref(updateSchemaName)],
-			description: `${name} global value`
-		};
-		const prefix = `${basePath}/globals/${name}`;
-		paths[prefix] = {
-			get: {
-				operationId: `global_${name}_get`,
-				summary: `Get ${name} global`,
-				tags: [tag],
-				parameters: [{
-					name: "locale",
-					in: "query",
-					schema: { type: "string" },
-					description: "Content locale"
-				}, stageQueryParameter()],
-				responses: jsonResponse(ref(valueSchemaName), `Current value of ${name} global`)
-			},
-			patch: {
-				operationId: `global_${name}_update`,
-				summary: `Update ${name} global`,
-				tags: [tag],
-				parameters: [stageQueryParameter()],
-				requestBody: jsonRequestBody(ref(updateSchemaName)),
-				responses: jsonResponse(ref(valueSchemaName), `Updated ${name} global`)
-			}
-		};
-		paths[`${prefix}/schema`] = { get: {
-			operationId: `global_${name}_schema`,
-			summary: `Get ${name} global introspection schema`,
-			tags: [tag],
-			responses: jsonResponse({
-				type: "object",
-				description: "Introspected global schema"
-			}, `Introspection schema for ${name} global`)
-		} };
-		paths[`${prefix}/versions`] = { get: {
-			operationId: `global_${name}_findVersions`,
-			summary: `List ${name} global versions`,
-			tags: [tag],
-			parameters: [
-				{
-					name: "id",
-					in: "query",
-					schema: { type: "string" },
-					description: "Global record ID"
-				},
-				{
-					name: "limit",
-					in: "query",
-					schema: { type: "number" },
-					description: "Maximum number of versions to return"
-				},
-				{
-					name: "offset",
-					in: "query",
-					schema: { type: "number" },
-					description: "Number of versions to skip"
-				}
-			],
-			responses: jsonResponse({
-				type: "array",
-				items: {
-					type: "object",
-					properties: {
-						id: { type: "string" },
-						versionId: { type: "string" },
-						versionNumber: { type: "number" },
-						versionOperation: { type: "string" },
-						versionUserId: { type: ["string", "null"] },
-						versionCreatedAt: {
-							type: "string",
-							format: "date-time"
-						}
-					}
-				}
-			}, `Version history for ${name} global`)
-		} };
-		paths[`${prefix}/revert`] = { post: {
-			operationId: `global_${name}_revertToVersion`,
-			summary: `Revert ${name} global to a version`,
-			tags: [tag],
-			parameters: [stageQueryParameter()],
-			requestBody: jsonRequestBody({
-				type: "object",
-				properties: {
-					id: { type: "string" },
-					version: { type: "number" },
-					versionId: { type: "string" }
-				}
-			}),
-			responses: jsonResponse(ref(valueSchemaName), `Reverted ${name} global value`)
-		} };
-		const versioningOpts = state.options?.versioning;
-		if (versioningOpts && typeof versioningOpts === "object" && versioningOpts.workflow) paths[`${prefix}/transition`] = { post: {
-			operationId: `global_${name}_transition`,
-			summary: `Transition ${name} global workflow stage`,
-			tags: [tag],
-			requestBody: jsonRequestBody({
-				type: "object",
-				required: ["stage"],
-				properties: { stage: {
-					type: "string",
-					description: "Target workflow stage"
-				} }
-			}),
-			responses: jsonResponse(ref(valueSchemaName), `Transitioned ${name} global value`)
-		} };
-	}
-	return {
-		paths,
-		schemas,
-		tags
-	};
-}
-function toPascalCase(str) {
-	return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
-}
-function buildGlobalSchemaFromFieldDefinitions(fieldDefinitions) {
-	if (!fieldDefinitions || typeof fieldDefinitions !== "object") return null;
-	const shape = {};
-	for (const [fieldName, fieldDefinition] of Object.entries(fieldDefinitions)) {
-		const fd = fieldDefinition;
-		if (typeof fd.toZodSchema !== "function") continue;
-		try {
-			const schema = fd.toZodSchema();
-			if (schema && typeof schema === "object" && "_def" in schema) shape[fieldName] = schema;
-		} catch {}
-	}
-	if (Object.keys(shape).length === 0) return null;
-	return z.toJSONSchema(z.object(shape).partial(), { unrepresentable: "any" });
-}
-
-//#endregion
-//#region src/generator/routes.ts
-/**
-* Convert camelCase to kebab-case, matching the HTTP adapter's URL generation.
-* e.g. "createBooking" → "create-booking"
-*/
-function camelToKebab(str) {
-	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-}
-/**
-* Flatten a routes tree into a list of { path, definition }.
-*/
-function flattenRoutesTree(tree, prefix = []) {
-	const entries = [];
-	for (const [key, value] of Object.entries(tree)) {
-		const segments = [...prefix, key];
-		if (value && typeof value === "object" && "handler" in value && typeof value.handler === "function") entries.push({
-			path: segments.join("/"),
-			segments,
-			definition: value
-		});
-		else if (value && typeof value === "object") entries.push(...flattenRoutesTree(value, segments));
-	}
-	return entries;
-}
-/**
-* Generate OpenAPI paths for all routes in the routes tree.
-*/
-function generateRoutePaths(routes, config) {
-	const paths = {};
-	const schemas = {};
-	const tags = [];
-	if (!routes) return {
-		paths,
-		schemas,
-		tags
-	};
-	const basePath = config.basePath ?? "/";
-	const entries = flattenRoutesTree(routes);
-	const tagSet = /* @__PURE__ */ new Set();
-	for (const entry of entries) {
-		const def = entry.definition;
-		const isRaw = def.mode === "raw";
-		const method = (def.method ?? "post").toLowerCase();
-		const topLevel = entry.segments[0] ?? "routes";
-		if (!tagSet.has(topLevel)) {
-			tagSet.add(topLevel);
-			tags.push({
-				name: `Routes: ${topLevel}`,
-				description: `Routes under ${topLevel}`
-			});
-		}
-		const operationId = `route_${entry.segments.join("_")}`;
-		const routePath = `${basePath}/${entry.segments.map(camelToKebab).join("/")}`;
-		const operation = {
-			operationId,
-			summary: entry.path,
-			tags: [`Routes: ${topLevel}`],
-			responses: {}
-		};
-		if (isRaw) {
-			operation.description = "Raw route - accepts any request body and returns a raw response.";
-			operation.requestBody = { content: {
-				"application/json": { schema: {} },
-				"application/octet-stream": { schema: {
-					type: "string",
-					format: "binary"
-				} }
-			} };
-			operation.responses = {
-				"200": { description: "Raw response" },
-				"401": {
-					description: "Unauthorized",
-					content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
-				}
-			};
-		} else {
-			let inputSchema = {};
-			let outputSchema = { type: "object" };
-			if (def.schema) {
-				const schemaName = `${operationId}_Input`;
-				schemas[schemaName] = zodToJsonSchema(def.schema);
-				inputSchema = { $ref: `#/components/schemas/${schemaName}` };
-			}
-			if (def.outputSchema) {
-				const schemaName = `${operationId}_Output`;
-				schemas[schemaName] = zodToJsonSchema(def.outputSchema);
-				outputSchema = { $ref: `#/components/schemas/${schemaName}` };
-			}
-			operation.requestBody = jsonRequestBody(inputSchema, "Route input");
-			operation.responses = jsonResponse(outputSchema, "Route output");
-		}
-		paths[routePath] = { [method]: operation };
-	}
-	return {
-		paths,
-		schemas,
-		tags
-	};
-}
-
-//#endregion
-//#region src/generator/search.ts
-/**
-* Generate OpenAPI paths for search endpoints.
-*/
-function generateSearchPaths(config) {
-	if (config.search === false) return {
-		paths: {},
-		tags: []
-	};
-	const basePath = config.basePath ?? "/";
-	const tag = "Search";
-	const paths = {};
-	paths[`${basePath}/search`] = { post: {
-		operationId: "search",
-		summary: "Search across collections",
-		tags: [tag],
-		requestBody: jsonRequestBody({
-			type: "object",
-			properties: {
-				query: {
-					type: "string",
-					description: "Search query"
-				},
-				collections: {
-					type: "array",
-					items: { type: "string" },
-					description: "Collections to search (omit for all)"
-				},
-				limit: {
-					type: "integer",
-					default: 10
-				},
-				offset: {
-					type: "integer",
-					default: 0
-				}
-			},
-			required: ["query"]
-		}),
-		responses: jsonResponse({
-			type: "object",
-			properties: {
-				results: {
-					type: "array",
-					items: {
-						type: "object",
-						properties: {
-							collection: { type: "string" },
-							doc: { type: "object" },
-							_search: {
-								type: "object",
-								properties: {
-									score: { type: "number" },
-									highlights: { type: "object" },
-									indexedTitle: { type: "string" }
-								}
-							}
-						}
-					}
-				},
-				totalResults: { type: "integer" }
-			}
-		}, "Search results")
-	} };
-	paths[`${basePath}/search/reindex/{collection}`] = { post: {
-		operationId: "search_reindex",
-		summary: "Reindex a collection",
-		description: "Requires admin authentication.",
-		tags: [tag],
-		parameters: [{
-			name: "collection",
-			in: "path",
-			required: true,
-			schema: { type: "string" },
-			description: "Collection name to reindex"
-		}],
-		responses: jsonResponse({
-			type: "object",
-			properties: {
-				success: { type: "boolean" },
-				collection: { type: "string" }
-			}
-		}, "Reindex started")
-	} };
-	return {
-		paths,
-		tags: [{
-			name: tag,
-			description: "Full-text search endpoints"
-		}]
-	};
-}
-
-//#endregion
-//#region src/generator/index.ts
-/**
-* Generate a complete OpenAPI 3.1 spec from a Questpie app instance and optional routes tree.
-*/
-function generateOpenApiSpec$1(app, routes, config = {}) {
-	const allPaths = {};
-	const allSchemas = { ...baseComponentSchemas() };
-	const allTags = [];
-	const collections = generateCollectionPaths(app, config);
-	Object.assign(allPaths, collections.paths);
-	Object.assign(allSchemas, collections.schemas);
-	allTags.push(...collections.tags);
-	const globals = generateGlobalPaths(app, config);
-	Object.assign(allPaths, globals.paths);
-	Object.assign(allSchemas, globals.schemas);
-	allTags.push(...globals.tags);
-	const routeResult = generateRoutePaths(routes, config);
-	Object.assign(allPaths, routeResult.paths);
-	Object.assign(allSchemas, routeResult.schemas);
-	allTags.push(...routeResult.tags);
-	const auth = generateAuthPaths(config);
-	Object.assign(allPaths, auth.paths);
-	allTags.push(...auth.tags);
-	const search = generateSearchPaths(config);
-	Object.assign(allPaths, search.paths);
-	allTags.push(...search.tags);
-	return {
-		openapi: "3.1.0",
-		info: {
-			title: config.info?.title ?? "QUESTPIE API",
-			version: config.info?.version ?? "1.0.0",
-			description: config.info?.description
-		},
-		servers: config.servers,
-		paths: allPaths,
-		components: {
-			schemas: allSchemas,
-			securitySchemes: {
-				bearerAuth: {
-					type: "http",
-					scheme: "bearer"
-				},
-				cookieAuth: {
-					type: "apiKey",
-					in: "cookie",
-					name: "better-auth.session_token"
-				}
-			}
-		},
-		tags: allTags,
-		security: [{ bearerAuth: [] }, { cookieAuth: [] }]
-	};
-}
-
-//#endregion
-//#region src/scalar.ts
-/**
-* Generate an HTML page that renders Scalar API reference UI.
-* The spec is inlined as JSON and Scalar is loaded from CDN.
-*/
-function serveScalarUI(spec, config) {
-	const title = config?.title ?? spec.info.title ?? "API Reference";
-	const scalarConfig = JSON.stringify({
-		theme: config?.theme ?? "purple",
-		hideDownloadButton: config?.hideDownloadButton,
-		defaultHttpClient: config?.defaultHttpClient,
-		customCss: config?.customCss,
-		content: spec
-	});
-	const html = `<!DOCTYPE html>
-<html>
-<head>
-  <title>${escapeHtml(title)}</title>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-</head>
-<body>
-  <script id="api-reference" data-configuration='${escapeAttr(scalarConfig)}'><\/script>
-  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
-</body>
-</html>`;
-	return new Response(html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
-}
-function escapeHtml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeAttr(str) {
-	return str.replace(/&/g, "&amp;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-//#endregion
-//#region src/server.ts
-/**
-* Identity factory for `config/openapi.ts` — provides type inference.
-*
-* @example
-* ```ts
-* // config/openapi.ts
-* import { openApiConfig } from "@questpie/openapi";
-*
-* export default openApiConfig({
-*   info: { title: "My API", version: "1.0.0" },
-*   scalar: { theme: "purple" },
-* });
-* ```
-*/
-function openApiConfig(config) {
-	return config;
-}
-/**
-* Generate a complete OpenAPI 3.1 spec from a QUESTPIE app instance.
-* Routes are read from `app.config.routes` automatically.
-*
-* @example
-* ```ts
-* import { generateOpenApiSpec } from "@questpie/openapi";
-*
-* const spec = generateOpenApiSpec(app, {
-*   info: { title: "My API", version: "1.0.0" },
-* });
-* ```
-*/
-function generateOpenApiSpec(app, config) {
-	const routes = app.config?.routes;
-	return generateOpenApiSpec$1(app, routes, config);
-}
-const specCache = /* @__PURE__ */ new WeakMap();
-function getCachedSpec(app, config) {
-	const appObj = app;
-	let cached = specCache.get(appObj);
-	if (!cached) {
-		const spec = generateOpenApiSpec(app, config);
-		const json = JSON.stringify(spec);
-		let hash = 0;
-		for (let i = 0; i < json.length; i++) hash = (hash << 5) - hash + json.charCodeAt(i) | 0;
-		cached = {
-			json,
-			etag: `"oapi-${(hash >>> 0).toString(36)}"`
-		};
-		specCache.set(appObj, cached);
-	}
-	return cached;
-}
-/**
-* Read OpenAPI config from `app.state.config.openapi` (set via config/openapi.ts).
-* Falls back to explicit config parameter if provided.
-*/
-function resolveOpenApiConfig(app, explicitConfig) {
-	if (explicitConfig) return explicitConfig;
-	return (app.state?.config)?.openapi;
-}
-/**
-* Create a route that serves the OpenAPI 3.1 JSON spec.
-* Place in your `routes/` directory for automatic discovery.
-*
-* Spec is lazy-generated on first request and cached with ETag.
-* Config is read from `config/openapi.ts` at request time, or from
-* explicit parameter if provided.
-*
-* @example
-* ```ts title="routes/openapi-spec.ts"
-* import { openApiRoute } from "@questpie/openapi";
-*
-* export default openApiRoute();
-* ```
-*/
-function openApiRoute(config) {
-	return route().get().raw().handler(async (ctx) => {
-		const app = ctx.app;
-		const { json, etag } = getCachedSpec(app, resolveOpenApiConfig(app, config));
-		if (ctx.request.headers.get("if-none-match") === etag) return new Response(null, { status: 304 });
-		return new Response(json, { headers: {
-			"Content-Type": "application/json",
-			"Cache-Control": "public, max-age=3600, stale-while-revalidate=43200",
-			ETag: etag,
-			"Access-Control-Allow-Origin": "*"
-		} });
-	});
-}
-/**
-* Create a route that serves the Scalar interactive API docs.
-* Place in your `routes/` directory for automatic discovery.
-*
-* @example
-* ```ts title="routes/docs.ts"
-* import { docsRoute } from "@questpie/openapi";
-*
-* export default docsRoute();
-* ```
-*/
-function docsRoute(config) {
-	const { scalar: scalarConfig, ...openApiConfig$1 } = config ?? {};
-	return route().get().raw().handler(async (ctx) => {
-		const app = ctx.app;
-		const resolved = resolveOpenApiConfig(app, openApiConfig$1);
-		const scalarOpts = scalarConfig ?? resolved?.scalar;
-		return serveScalarUI(generateOpenApiSpec(app, resolved), scalarOpts);
-	});
-}
-/**
-* OpenAPI module — registers spec + docs routes.
-*
-* Routes are served as:
-* - `GET /api/openapi.json` — OpenAPI 3.1 JSON spec
-* - `GET /api/docs` — Scalar interactive API reference
-*
-* Configure via `config/openapi.ts`:
-* ```ts
-* import { openApiConfig } from "@questpie/openapi";
-* export default openApiConfig({ info: { title: "My API", version: "1.0.0" } });
-* ```
-*
-* @example Static (reads config from config/openapi.ts):
-* ```ts title="questpie/server/modules.ts"
-* import { openApiModule } from "@questpie/openapi";
-* export default [openApiModule] as const;
-* ```
-*/
-const openApiModule = module({
-	name: "questpie-openapi",
-	plugin: openApiPlugin(),
-	routes: {
-		"openapi.json": openApiRoute(),
-		docs: docsRoute()
-	}
-});
-var server_default = openApiModule;
-
-//#endregion
 export { server_default as default, docsRoute, generateOpenApiSpec, openApiConfig, openApiModule, openApiRoute };