@questpie/openapi 3.0.19 → 3.0.21

package/README.md

@@ -14,8 +14,8 @@ Register `openApiModule` in your `modules.ts` file to add `/openapi.json` and `/
 
 ```ts
 // src/questpie/server/modules.ts
-import { adminModule } from "@questpie/admin/server";
-import { openApiModule } from "@questpie/openapi";
+import { adminModule } from "@questpie/admin/modules/admin";
+import { openApiModule } from "@questpie/openapi/modules/openapi";
 
 export default [adminModule, openApiModule] as const;
 ```
@@ -24,7 +24,7 @@ Configure the OpenAPI module via `config/openapi.ts`:
 
 ```ts
 // src/questpie/server/config/openapi.ts
-import { openApiConfig } from "@questpie/openapi";
+import { openApiConfig } from "@questpie/openapi/server";
 
 export default openApiConfig({
 	info: { title: "My API", version: "1.0.0" },
@@ -36,7 +36,7 @@ Your route handler stays clean — no wrapper needed:
 
 ```ts
 // routes/api/$.ts
-import { createFetchHandler } from "questpie";
+import { createFetchHandler } from "questpie/http";
 import { app } from "#questpie";
 
 const handler = createFetchHandler(app, { basePath: "/api" });
@@ -66,7 +66,7 @@ Routes with an explicit `outputSchema` get full request/response documentation.
 Generate the spec without mounting routes:
 
 ```ts
-import { generateOpenApiSpec } from "@questpie/openapi";
+import { generateOpenApiSpec } from "@questpie/openapi/server";
 
 const spec = generateOpenApiSpec(app, {
 	basePath: "/api",

package/dist/modules/openapi.d.mts

@@ -0,0 +1,2 @@
+import { i as openApiModule } from "../server-C8504hNI.mjs";
+export { openApiModule };

package/dist/modules/openapi.mjs

@@ -0,0 +1,3 @@
+import { i as openApiModule } from "../server-DsUIkt4E.mjs";
+
+export { openApiModule };

package/dist/plugin-CbmRC5nO.mjs

@@ -0,0 +1,30 @@
+//#region src/plugin.ts
+function openApiPlugin() {
+	return {
+		name: "questpie-openapi",
+		targets: { server: {
+			root: ".",
+			outputFile: "index.ts",
+			discover: { openapi: {
+				pattern: "config/openapi.ts",
+				configKey: "openapi"
+			} },
+			registries: { singletonFactories: { openapi: {
+				configType: "OpenApiModuleConfig",
+				imports: [{
+					name: "OpenApiModuleConfig",
+					from: "@questpie/openapi"
+				}]
+			} } },
+			transform: (ctx) => {
+				const routes = ctx.categories.get("routes");
+				if (!routes?.size) return;
+				const union = [...routes.keys()].map((k) => `"${k}"`).join(" | ");
+				ctx.addTypeDeclaration(`export type AppRouteKeys = ${union};`);
+			}
+		} }
+	};
+}
+
+//#endregion
+export { openApiPlugin as t };

package/dist/plugin.mjs

@@ -1,30 +1,3 @@
-//#region src/plugin.ts
-function openApiPlugin() {
-	return {
-		name: "questpie-openapi",
-		targets: { server: {
-			root: ".",
-			outputFile: "index.ts",
-			discover: { openapi: {
-				pattern: "config/openapi.ts",
-				configKey: "openapi"
-			} },
-			registries: { singletonFactories: { openapi: {
-				configType: "OpenApiModuleConfig",
-				imports: [{
-					name: "OpenApiModuleConfig",
-					from: "@questpie/openapi"
-				}]
-			} } },
-			transform: (ctx) => {
-				const routes = ctx.categories.get("routes");
-				if (!routes?.size) return;
-				const union = [...routes.keys()].map((k) => `"${k}"`).join(" | ");
-				ctx.addTypeDeclaration(`export type AppRouteKeys = ${union};`);
-			}
-		} }
-	};
-}
+import { t as openApiPlugin } from "./plugin-CbmRC5nO.mjs";
 
-//#endregion
 export { openApiPlugin };

package/dist/server-C8504hNI.d.mts

@@ -0,0 +1,186 @@
+import * as questpie0 from "questpie";
+
+//#region src/types.d.ts
+/**
+ * Configuration for OpenAPI spec generation.
+ */
+interface OpenApiConfig {
+  /** OpenAPI info object */
+  info?: {
+    title?: string;
+    version?: string;
+    description?: string;
+  };
+  /** Server definitions */
+  servers?: Array<{
+    url: string;
+    description?: string;
+  }>;
+  /** Base path for routes (must match your adapter basePath) */
+  basePath?: string;
+  /** Exclude specific collections or globals from the spec */
+  exclude?: {
+    collections?: string[];
+    globals?: string[];
+  };
+  /** Include auth endpoints in the spec */
+  auth?: boolean;
+  /** Include search endpoints in the spec */
+  search?: boolean;
+}
+/**
+ * Scalar UI configuration options.
+ */
+interface ScalarConfig {
+  /** Theme for Scalar UI */
+  theme?: string;
+  /** Page title override */
+  title?: string;
+  /** Custom CSS */
+  customCss?: string;
+  /** Hide the "Download OpenAPI Spec" button */
+  hideDownloadButton?: boolean;
+  /** Default HTTP client for code samples */
+  defaultHttpClient?: {
+    targetKey: string;
+    clientKey: string;
+  };
+}
+/**
+ * Configuration for the OpenAPI module.
+ * Export from `config/openapi.ts` via `openApiConfig()`.
+ */
+interface OpenApiModuleConfig extends OpenApiConfig {
+  /** Scalar UI options */
+  scalar?: ScalarConfig;
+  /** Path for the JSON spec route (default: "openapi.json") */
+  specPath?: string;
+  /** Path for the Scalar UI docs route (default: "docs") */
+  docsPath?: string;
+}
+/**
+ * OpenAPI 3.1 spec (simplified type — full spec is a plain object).
+ */
+type OpenApiSpec = {
+  openapi: "3.1.0";
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  servers?: Array<{
+    url: string;
+    description?: string;
+  }>;
+  paths: Record<string, Record<string, PathOperation>>;
+  components: {
+    schemas: Record<string, unknown>;
+    securitySchemes?: Record<string, unknown>;
+  };
+  tags?: Array<{
+    name: string;
+    description?: string;
+  }>;
+  security?: Array<Record<string, string[]>>;
+};
+interface PathOperation {
+  operationId?: string;
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  parameters?: unknown[];
+  requestBody?: unknown;
+  responses: Record<string, unknown>;
+  security?: Array<Record<string, string[]>>;
+}
+//#endregion
+//#region src/server.d.ts
+
+/**
+ * Identity factory for `config/openapi.ts` — provides type inference.
+ *
+ * @example
+ * ```ts
+ * // config/openapi.ts
+ * import { openApiConfig } from "@questpie/openapi/server";
+ *
+ * export default openApiConfig({
+ *   info: { title: "My API", version: "1.0.0" },
+ *   scalar: { theme: "purple" },
+ * });
+ * ```
+ */
+declare function openApiConfig(config: OpenApiModuleConfig): OpenApiModuleConfig;
+/**
+ * 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/server";
+ *
+ * const spec = generateOpenApiSpec(app, {
+ *   info: { title: "My API", version: "1.0.0" },
+ * });
+ * ```
+ */
+declare function generateOpenApiSpec(app: unknown, config?: OpenApiConfig): OpenApiSpec;
+/**
+ * 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/server";
+ *
+ * export default openApiRoute();
+ * ```
+ */
+declare function openApiRoute(config?: OpenApiConfig): questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+/**
+ * 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/server";
+ *
+ * export default docsRoute();
+ * ```
+ */
+declare function docsRoute(config?: OpenApiConfig & {
+  scalar?: ScalarConfig;
+}): questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+/**
+ * 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/server";
+ * 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/server";
+ * export default [openApiModule] as const;
+ * ```
+ */
+declare const openApiModule: {
+  name: "questpie-openapi";
+  plugin: questpie0.CodegenPlugin;
+  routes: {
+    "openapi.json": questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+    docs: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+  };
+};
+//#endregion
+export { openApiRoute as a, OpenApiSpec as c, openApiModule as i, ScalarConfig as l, generateOpenApiSpec as n, OpenApiConfig as o, openApiConfig as r, OpenApiModuleConfig as s, docsRoute as t };