@duplojs/http 0.1.0 → 0.4.0

package/dist/plugins/codeGenerator/stepsToDataParser.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+require('../../core/steps/index.cjs');
+var utils = require('@duplojs/utils');
+var process = require('../../core/steps/process.cjs');
+var extract = require('../../core/steps/extract.cjs');
+var presetChecker = require('../../core/steps/presetChecker.cjs');
+var checker = require('../../core/steps/checker.cjs');
+var cut = require('../../core/steps/cut.cjs');
+var handler = require('../../core/steps/handler.cjs');
+
+function stepsToDataParser(steps, params) {
+    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), utils.O.to({
+        entrypointContract: utils.A.map((result) => result.entrypointContract),
+        endpointContract: utils.A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => utils.pipe(lastValue, utils.O.entries, utils.A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (utils.DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!utils.DP.dataParserKind.has(accumulatorValue)
+                && utils.O.countKeys(accumulatorValue) > 1
+                && utils.DP.dataParserKind.has(currentExtractDataParser)
+                && !utils.DP.objectKind.has(currentExtractDataParser))) {
+            return utils.O.entry(key, accumulatorValue);
+        }
+        if (!utils.DP.dataParserKind.has(currentExtractDataParser)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (utils.DP.identifier(currentExtractDataParser, utils.DP.objectKind)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return utils.O.entry(key, currentExtractDataParser);
+    }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+        .when(process.processStepKind.has, () => [])
+        .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(utils.hasSomeKinds([
+        checker.checkerStepKind,
+        cut.cutStepKind,
+        handler.handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), utils.A.map(({ code, information, body }) => utils.DP.object({
+        code: utils.DP.literal(code),
+        information: utils.DP.literal(information),
+        body,
+    })), utils.A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+exports.stepsToDataParser = stepsToDataParser;

package/dist/plugins/codeGenerator/stepsToDataParser.d.ts

@@ -0,0 +1,14 @@
+import { type Steps } from "../../core/steps";
+import { DP } from "@duplojs/utils";
+import { type EntrypointKey } from "./types";
+import { type ResponseContract } from "../../core/response";
+type EntrypointReduceResult = Record<EntrypointKey, DP.DataParser | Record<string, DP.DataParser>>;
+export interface StepsToDataParserParams {
+    readonly defaultExtractContract: ResponseContract.Contract;
+}
+export interface StepsToDataParserResult {
+    entrypointContract: EntrypointReduceResult;
+    endpointContract: DP.DataParser[];
+}
+export declare function stepsToDataParser(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
+export {};

package/dist/plugins/codeGenerator/stepsToDataParser.mjs

@@ -0,0 +1,64 @@
+import '../../core/steps/index.mjs';
+import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { processStepKind } from '../../core/steps/process.mjs';
+import { extractStepKind } from '../../core/steps/extract.mjs';
+import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
+import { checkerStepKind } from '../../core/steps/checker.mjs';
+import { cutStepKind } from '../../core/steps/cut.mjs';
+import { handlerStepKind } from '../../core/steps/handler.mjs';
+
+function stepsToDataParser(steps, params) {
+    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), O.to({
+        entrypointContract: A.map((result) => result.entrypointContract),
+        endpointContract: A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => pipe(lastValue, O.entries, A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!DP.dataParserKind.has(accumulatorValue)
+                && O.countKeys(accumulatorValue) > 1
+                && DP.dataParserKind.has(currentExtractDataParser)
+                && !DP.objectKind.has(currentExtractDataParser))) {
+            return O.entry(key, accumulatorValue);
+        }
+        if (!DP.dataParserKind.has(currentExtractDataParser)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (DP.identifier(currentExtractDataParser, DP.objectKind)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return O.entry(key, currentExtractDataParser);
+    }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+        .when(processStepKind.has, () => [])
+        .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(hasSomeKinds([
+        checkerStepKind,
+        cutStepKind,
+        handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), A.map(({ code, information, body }) => DP.object({
+        code: DP.literal(code),
+        information: DP.literal(information),
+        body,
+    })), A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+export { stepsToDataParser };

package/dist/plugins/codeGenerator/types/entrypointKey.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/plugins/codeGenerator/types/entrypointKey.d.ts

@@ -0,0 +1 @@
+export type EntrypointKey = "query" | "body" | "params" | "headers";

package/dist/plugins/codeGenerator/types/entrypointKey.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/codeGenerator/types/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./entrypointKey.cjs');
+

package/dist/plugins/codeGenerator/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./entrypointKey";

package/dist/plugins/codeGenerator/types/index.mjs

@@ -0,0 +1 @@
+import './entrypointKey.mjs';

package/dist/plugins/openApiGenerator/aggregateStepContract.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+require('../../core/steps/index.cjs');
+var utils = require('@duplojs/utils');
+var process = require('../../core/steps/process.cjs');
+var extract = require('../../core/steps/extract.cjs');
+var presetChecker = require('../../core/steps/presetChecker.cjs');
+var checker = require('../../core/steps/checker.cjs');
+var cut = require('../../core/steps/cut.cjs');
+var handler = require('../../core/steps/handler.cjs');
+
+function aggregateStepContract(steps, params) {
+    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
+        entrypointContract: utils.A.map((result) => result.entrypointContract),
+        endpointContract: utils.A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => utils.pipe(lastValue, utils.O.entries, utils.A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (utils.DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!utils.DP.dataParserKind.has(accumulatorValue)
+                && utils.O.countKeys(accumulatorValue) > 1
+                && utils.DP.dataParserKind.has(currentExtractDataParser)
+                && !utils.DP.objectKind.has(currentExtractDataParser))) {
+            return utils.O.entry(key, accumulatorValue);
+        }
+        if (!utils.DP.dataParserKind.has(currentExtractDataParser)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (utils.DP.identifier(currentExtractDataParser, utils.DP.objectKind)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return utils.O.entry(key, currentExtractDataParser);
+    }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+        .when(process.processStepKind.has, () => [])
+        .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(utils.hasSomeKinds([
+        checker.checkerStepKind,
+        cut.cutStepKind,
+        handler.handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), utils.A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+exports.aggregateStepContract = aggregateStepContract;

package/dist/plugins/openApiGenerator/aggregateStepContract.d.ts

@@ -0,0 +1,18 @@
+import { type Steps } from "../../core/steps";
+import { DP } from "@duplojs/utils";
+import type { ResponseCode, ResponseContract } from "../../core/response";
+import type { EntrypointKey } from "./types";
+export interface EndpointRouteResult {
+    code: ResponseCode;
+    information: string;
+    body: DP.DataParser;
+}
+export type EntrypointReduceResult = Record<EntrypointKey, DP.DataParser | Record<string, DP.DataParser>>;
+export interface AggregateStepsResult {
+    entrypointContract: EntrypointReduceResult;
+    endpointContract: EndpointRouteResult[];
+}
+export interface AggregateStepsParams {
+    readonly defaultExtractContract: ResponseContract.Contract;
+}
+export declare function aggregateStepContract(steps: readonly Steps[], params: AggregateStepsParams): AggregateStepsResult;

package/dist/plugins/openApiGenerator/aggregateStepContract.mjs

@@ -0,0 +1,60 @@
+import '../../core/steps/index.mjs';
+import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { processStepKind } from '../../core/steps/process.mjs';
+import { extractStepKind } from '../../core/steps/extract.mjs';
+import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
+import { checkerStepKind } from '../../core/steps/checker.mjs';
+import { cutStepKind } from '../../core/steps/cut.mjs';
+import { handlerStepKind } from '../../core/steps/handler.mjs';
+
+function aggregateStepContract(steps, params) {
+    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
+        entrypointContract: A.map((result) => result.entrypointContract),
+        endpointContract: A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => pipe(lastValue, O.entries, A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!DP.dataParserKind.has(accumulatorValue)
+                && O.countKeys(accumulatorValue) > 1
+                && DP.dataParserKind.has(currentExtractDataParser)
+                && !DP.objectKind.has(currentExtractDataParser))) {
+            return O.entry(key, accumulatorValue);
+        }
+        if (!DP.dataParserKind.has(currentExtractDataParser)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (DP.identifier(currentExtractDataParser, DP.objectKind)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return O.entry(key, currentExtractDataParser);
+    }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+        .when(processStepKind.has, () => [])
+        .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(hasSomeKinds([
+        checkerStepKind,
+        cutStepKind,
+        handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+export { aggregateStepContract };

package/dist/plugins/openApiGenerator/index.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+require('@duplojs/data-parser-tools/toJsonSchema');
+require('./types/index.cjs');
+var plugin = require('./plugin.cjs');
+var routeToOpenApi = require('./routeToOpenApi.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
+var makeOpenApiRoute = require('./makeOpenApiRoute.cjs');
+var makeOpenApiPage = require('./makeOpenApiPage.cjs');
+
+
+
+exports.openApiGeneratorPlugin = plugin.openApiGeneratorPlugin;
+exports.routeToOpenApi = routeToOpenApi.routeToOpenApi;
+exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
+exports.makeOpenApiRoute = makeOpenApiRoute.makeOpenApiRoute;
+exports.makeOpenApiPage = makeOpenApiPage.makeOpenApiPage;

package/dist/plugins/openApiGenerator/index.d.ts

@@ -0,0 +1,7 @@
+import "@duplojs/data-parser-tools/toJsonSchema";
+export * from "./types";
+export * from "./plugin";
+export * from "./routeToOpenApi";
+export * from "./aggregateStepContract";
+export * from "./makeOpenApiRoute";
+export * from "./makeOpenApiPage";

package/dist/plugins/openApiGenerator/index.mjs

@@ -0,0 +1,7 @@
+import '@duplojs/data-parser-tools/toJsonSchema';
+import './types/index.mjs';
+export { openApiGeneratorPlugin } from './plugin.mjs';
+export { routeToOpenApi } from './routeToOpenApi.mjs';
+export { aggregateStepContract } from './aggregateStepContract.mjs';
+export { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
+export { makeOpenApiPage } from './makeOpenApiPage.mjs';

package/dist/plugins/openApiGenerator/makeOpenApiPage.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+function makeOpenApiPage(params) {
+    return /* html */ `
+	<!DOCTYPE html>
+	<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<meta name="description" content="SwaggerUI"/>
+		<title>${params.pageTitle}</title>
+		<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@${params.swaggerUiVersion}/swagger-ui.css" />
+		<script src="https://unpkg.com/swagger-ui-dist@${params.swaggerUiVersion}/swagger-ui-bundle.js" crossorigin></script>
+	</head>
+	<body>
+	<div id="swagger-ui"></div>
+	<script>
+		window.onload = () => {
+			window.ui = SwaggerUIBundle({
+				spec: ${params.openApiDocument},
+				dom_id: "#swagger-ui",
+			});
+		};
+	</script>
+	</body>
+	</html>
+	`;
+}
+
+exports.makeOpenApiPage = makeOpenApiPage;

package/dist/plugins/openApiGenerator/makeOpenApiPage.d.ts

@@ -0,0 +1,7 @@
+interface MakeOpenApiPageParams {
+    pageTitle: string;
+    openApiDocument: string;
+    swaggerUiVersion: string;
+}
+export declare function makeOpenApiPage(params: MakeOpenApiPageParams): string;
+export {};

package/dist/plugins/openApiGenerator/makeOpenApiPage.mjs

@@ -0,0 +1,28 @@
+function makeOpenApiPage(params) {
+    return /* html */ `
+	<!DOCTYPE html>
+	<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<meta name="description" content="SwaggerUI"/>
+		<title>${params.pageTitle}</title>
+		<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@${params.swaggerUiVersion}/swagger-ui.css" />
+		<script src="https://unpkg.com/swagger-ui-dist@${params.swaggerUiVersion}/swagger-ui-bundle.js" crossorigin></script>
+	</head>
+	<body>
+	<div id="swagger-ui"></div>
+	<script>
+		window.onload = () => {
+			window.ui = SwaggerUIBundle({
+				spec: ${params.openApiDocument},
+				dom_id: "#swagger-ui",
+			});
+		};
+	</script>
+	</body>
+	</html>
+	`;
+}
+
+export { makeOpenApiPage };

package/dist/plugins/openApiGenerator/makeOpenApiRoute.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+require('../../core/builders/index.cjs');
+require('../../core/response/index.cjs');
+var utils = require('@duplojs/utils');
+var builder = require('../../core/builders/route/builder.cjs');
+var contract = require('../../core/response/contract.cjs');
+
+function makeOpenApiRoute(routePath, openApiPage) {
+    return builder.useRouteBuilder("GET", routePath)
+        .handler(contract.ResponseContract.ok("swaggerUi", utils.DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
+        .setHeader("content-type", "text/html"));
+}
+
+exports.makeOpenApiRoute = makeOpenApiRoute;

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -0,0 +1,18 @@
+import { ResponseContract } from "../../core/response";
+import type { RoutePath } from "../../core/route";
+import { DP } from "@duplojs/utils";
+export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
+    readonly method: "GET";
+    readonly hooks: readonly [];
+    readonly preflightSteps: readonly [];
+    readonly paths: readonly [`/${string}`];
+    readonly steps: readonly [import("../../core/steps").HandlerStep<{
+        readonly responseContract: NoInfer<ResponseContract.Contract<"200", "swaggerUi", DP.DataParserString<{
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly coerce: boolean;
+            readonly checkers: readonly [];
+        }>>>;
+        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>;
+    }>];
+}>;

package/dist/plugins/openApiGenerator/makeOpenApiRoute.mjs

@@ -0,0 +1,13 @@
+import '../../core/builders/index.mjs';
+import '../../core/response/index.mjs';
+import { DP } from '@duplojs/utils';
+import { useRouteBuilder } from '../../core/builders/route/builder.mjs';
+import { ResponseContract } from '../../core/response/contract.mjs';
+
+function makeOpenApiRoute(routePath, openApiPage) {
+    return useRouteBuilder("GET", routePath)
+        .handler(ResponseContract.ok("swaggerUi", DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
+        .setHeader("content-type", "text/html"));
+}
+
+export { makeOpenApiRoute };

package/dist/plugins/openApiGenerator/plugin.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var routeToOpenApi = require('./routeToOpenApi.cjs');
+var utils = require('@duplojs/utils');
+var makeOpenApiPage = require('./makeOpenApiPage.cjs');
+var makeOpenApiRoute = require('./makeOpenApiRoute.cjs');
+var promises = require('fs/promises');
+
+function openApiGeneratorPlugin(pluginParams) {
+    return () => ({
+        name: "open-api-generator",
+        hooksHubLifeCycle: [
+            {
+                beforeServerBuildRoutes: async (hub) => {
+                    const contextToJsonSchemaFactory = new Map();
+                    const resultSchemaContext = new Map();
+                    const routes = hub.aggregatesRoutes();
+                    const openApiRoutes = utils.pipe(routes, utils.A.filter((route) => route.definition.method !== "OPTIONS"), utils.A.flatMap((route) => routeToOpenApi.routeToOpenApi(route, {
+                        defaultExtractContract: hub.defaultExtractContract,
+                        resultSchemaContext,
+                        contextToJsonSchemaFactory,
+                    })));
+                    if (!utils.A.minElements(openApiRoutes, 1)) {
+                        return;
+                    }
+                    const paths = utils.pipe(openApiRoutes, utils.A.group((element, { output }) => output(element.path, element)), utils.O.entries, utils.A.filter((entry) => entry[1] !== undefined), utils.A.map(([path, value]) => utils.pipe(value, utils.A.group(({ method, path, ...rest }, { output }) => output(method, rest)), utils.O.entries, utils.A.filter((entry) => entry[1] !== undefined), utils.A.map(([method, value]) => utils.O.entry(method, utils.A.first(value))), utils.O.fromEntries, (value) => utils.O.entry(path, value))), utils.O.fromEntries);
+                    const schemaComponents = utils.G.reduce(resultSchemaContext.values(), utils.G.reduceFrom({}), ({ lastValue, element, nextWithObject }) => nextWithObject(lastValue, element));
+                    const securityScheme = utils.P.match(pluginParams.security)
+                        .with({ type: "bearer" }, (security) => ({
+                        type: "http",
+                        scheme: "bearer",
+                        bearerFormat: security.bearerFormat ?? "JWT",
+                    }))
+                        .with({ type: "basic" }, utils.justReturn({
+                        type: "http",
+                        scheme: "basic",
+                    }))
+                        .with({ type: "apiKey" }, (security) => ({
+                        type: "apiKey",
+                        name: security.paramName,
+                        in: security.in,
+                    }))
+                        .otherwise(utils.justReturn(undefined));
+                    const securitySchemeName = "auth";
+                    const securitySchemes = securityScheme
+                        ? {
+                            [securitySchemeName]: securityScheme,
+                        }
+                        : undefined;
+                    const openApiDocument = {
+                        openapi: "3.1.0",
+                        info: {
+                            title: pluginParams.title ?? "Swagger API",
+                            version: pluginParams.version ?? "0.0.0",
+                            summary: pluginParams.summary,
+                            contact: pluginParams.contact,
+                            license: pluginParams.license,
+                        },
+                        servers: pluginParams.servers,
+                        paths,
+                        components: {
+                            schemas: schemaComponents,
+                            securitySchemes,
+                        },
+                        security: pluginParams.security
+                            ? [
+                                {
+                                    [securitySchemeName]: [],
+                                },
+                            ]
+                            : undefined,
+                    };
+                    const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
+                    if (pluginParams.outputFilePath) {
+                        await promises.writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    }
+                    const openApiPage = makeOpenApiPage.makeOpenApiPage({
+                        openApiDocument: openApiDocumentString,
+                        pageTitle: pluginParams.title ?? "Swagger API",
+                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                    });
+                    const openApiRoute = makeOpenApiRoute.makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                    return hub.register(openApiRoute);
+                },
+            },
+        ],
+    });
+}
+
+exports.openApiGeneratorPlugin = openApiGeneratorPlugin;

package/dist/plugins/openApiGenerator/plugin.d.ts

@@ -0,0 +1,49 @@
+import type { HubPlugin } from "../../core/hub";
+import type { RoutePath } from "../../core/route";
+import type { SupportedBearerFormat } from "./types";
+interface OpenApiSecurityOptionBearer {
+    type: "bearer";
+    bearerFormat?: SupportedBearerFormat;
+}
+interface OpenApiSecurityOptionApiKey {
+    type: "apiKey";
+    paramName: string;
+    in: "header" | "query" | "cookie";
+}
+interface OpenApiSecurityOptionBasic {
+    type: "basic";
+}
+export interface OpenApiGeneratorPluginParams {
+    routePath: RoutePath;
+    outputFilePath?: string;
+    /**
+     * @default "Swagger API"
+     */
+    title?: string;
+    /**
+     * @default "0.0.0"
+     */
+    version?: string;
+    summary?: string;
+    contact?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+        identifier?: string;
+    };
+    security?: OpenApiSecurityOptionBearer | OpenApiSecurityOptionApiKey | OpenApiSecurityOptionBasic;
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    /**
+     * @default "5.31.0"
+     */
+    swaggerUiVersion?: string;
+}
+export declare function openApiGeneratorPlugin(pluginParams: OpenApiGeneratorPluginParams): () => HubPlugin;
+export {};