@duplojs/http 0.2.0 → 0.4.0

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 {};

package/dist/plugins/openApiGenerator/plugin.mjs

@@ -0,0 +1,88 @@
+import { routeToOpenApi } from './routeToOpenApi.mjs';
+import { pipe, A, O, G, P, justReturn } from '@duplojs/utils';
+import { makeOpenApiPage } from './makeOpenApiPage.mjs';
+import { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
+import { writeFile } from '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 = pipe(routes, A.filter((route) => route.definition.method !== "OPTIONS"), A.flatMap((route) => routeToOpenApi(route, {
+                        defaultExtractContract: hub.defaultExtractContract,
+                        resultSchemaContext,
+                        contextToJsonSchemaFactory,
+                    })));
+                    if (!A.minElements(openApiRoutes, 1)) {
+                        return;
+                    }
+                    const paths = pipe(openApiRoutes, A.group((element, { output }) => output(element.path, element)), O.entries, A.filter((entry) => entry[1] !== undefined), A.map(([path, value]) => pipe(value, A.group(({ method, path, ...rest }, { output }) => output(method, rest)), O.entries, A.filter((entry) => entry[1] !== undefined), A.map(([method, value]) => O.entry(method, A.first(value))), O.fromEntries, (value) => O.entry(path, value))), O.fromEntries);
+                    const schemaComponents = G.reduce(resultSchemaContext.values(), G.reduceFrom({}), ({ lastValue, element, nextWithObject }) => nextWithObject(lastValue, element));
+                    const securityScheme = P.match(pluginParams.security)
+                        .with({ type: "bearer" }, (security) => ({
+                        type: "http",
+                        scheme: "bearer",
+                        bearerFormat: security.bearerFormat ?? "JWT",
+                    }))
+                        .with({ type: "basic" }, justReturn({
+                        type: "http",
+                        scheme: "basic",
+                    }))
+                        .with({ type: "apiKey" }, (security) => ({
+                        type: "apiKey",
+                        name: security.paramName,
+                        in: security.in,
+                    }))
+                        .otherwise(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 writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    }
+                    const openApiPage = makeOpenApiPage({
+                        openApiDocument: openApiDocumentString,
+                        pageTitle: pluginParams.title ?? "Swagger API",
+                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                    });
+                    const openApiRoute = makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                    return hub.register(openApiRoute);
+                },
+            },
+        ],
+    });
+}
+
+export { openApiGeneratorPlugin };

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+var aggregateStepContract = require('./aggregateStepContract.cjs');
+var utils = require('@duplojs/utils');
+var toJsonSchema = require('@duplojs/data-parser-tools/toJsonSchema');
+
+function factoryJsonSchema(params) {
+    const identifier = params.schema.definition.identifier
+        ?? `NotIdentified${params.resultSchemaContext.size}`;
+    const renderResult = toJsonSchema.render(params.schema, {
+        identifier,
+        mode: params.mode,
+        context: params.context,
+        version: "openApi31",
+        transformers: toJsonSchema.defaultTransformers,
+    });
+    params.resultSchemaContext.set(identifier, renderResult.components.schemas);
+    return utils.O.pick(renderResult, { $ref: true });
+}
+const parameterKeyMapper = {
+    query: "query",
+    params: "path",
+    headers: "header",
+};
+const methodMapper = {
+    GET: "get",
+    POST: "post",
+    PUT: "put",
+    DELETE: "delete",
+    HEAD: "head",
+    TRACE: "trace",
+    CONNECT: "connect",
+    OPTIONS: "options",
+};
+function routeToOpenApi(route, params) {
+    const aggregateStepResult = aggregateStepContract.aggregateStepContract([
+        ...route.definition.preflightSteps,
+        ...route.definition.steps,
+    ], {
+        defaultExtractContract: params.defaultExtractContract,
+    });
+    const { body, ...restEntrypoint } = aggregateStepResult.entrypointContract;
+    const parameters = utils.pipe(restEntrypoint, utils.O.entries, utils.A.select(({ element: [key, value], select, skip }) => !utils.DP.dataParserKind.has(value) && utils.O.countKeys(value)
+        ? select(utils.O.entry(key, utils.O.entries(value)))
+        : skip()), utils.A.flatMap(([key, value]) => utils.A.map(value, ([name, schema]) => ({
+        name,
+        in: parameterKeyMapper[key],
+        required: !utils.DP.identifier(schema, utils.DP.optionalKind),
+        schema: factoryJsonSchema({
+            context: params.contextToJsonSchemaFactory,
+            resultSchemaContext: params.resultSchemaContext,
+            mode: "in",
+            schema,
+        }),
+    }))));
+    const requestBody = utils.pipe(body, utils.when((value) => utils.O.countKeys(value) === 0, utils.justReturn(utils.DP.empty())), utils.whenNot(utils.DP.dataParserKind.has, utils.DP.object), utils.P.when(utils.DP.identifier(utils.DP.emptyKind), utils.justReturn(undefined)), utils.P.when(utils.DP.identifier(utils.DP.objectKind), (objectSchema) => ({
+        required: true,
+        content: {
+            "application/json": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), utils.P.otherwise((primitiveSchema) => ({
+        required: true,
+        content: {
+            "text/plain": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: primitiveSchema,
+                }),
+            },
+        },
+    })));
+    const responses = utils.pipe(aggregateStepResult.endpointContract, utils.A.reduce(utils.A.reduceFrom({}), ({ lastValue, element: { information, body, code }, nextWithObject }) => {
+        const schemaResponse = !utils.DP.identifier(body, utils.DP.emptyKind)
+            ? factoryJsonSchema({
+                context: params.contextToJsonSchemaFactory,
+                resultSchemaContext: params.resultSchemaContext,
+                mode: "in",
+                schema: body,
+            })
+            : undefined;
+        const headerInformation = {
+            const: information,
+            type: "string",
+        };
+        const headerDescription = utils.P.match(lastValue[code])
+            .when(utils.isType("object"), (value) => {
+            if (utils.S.includes(value.headers.information.description, information)) {
+                return value.headers.information.description;
+            }
+            return utils.S.concat(value.headers.information.description, " | ", information);
+        })
+            .when(utils.isType("undefined"), utils.justReturn(information))
+            .exhaustive();
+        const headers = {
+            information: {
+                schema: lastValue[code]
+                    ? {
+                        anyOf: [
+                            lastValue[code].headers.information.schema,
+                            headerInformation,
+                        ],
+                    }
+                    : headerInformation,
+                description: headerDescription,
+            },
+        };
+        const content = utils.pipe(body, utils.P.when(utils.DP.identifier(utils.DP.emptyKind), utils.justReturn(lastValue[code]?.content)), utils.P.otherwise((value) => {
+            if (utils.DP.identifier(value, utils.DP.stringKind) && lastValue[code]?.content?.["plain/text"]) {
+                return lastValue[code].content;
+            }
+            if (utils.DP.identifier(value, utils.DP.stringKind)) {
+                return {
+                    ...lastValue[code]?.content,
+                    "plain/text": {
+                        schema: schemaResponse,
+                    },
+                };
+            }
+            if (utils.DP.identifier(value, utils.DP.objectKind) && lastValue[code]?.content?.["application/json"]) {
+                return {
+                    ...lastValue[code]?.content,
+                    "application/json": {
+                        schema: {
+                            anyOf: [
+                                lastValue[code].content["application/json"].schema,
+                                schemaResponse,
+                            ],
+                        },
+                    },
+                };
+            }
+            return {
+                "application/json": {
+                    schema: schemaResponse,
+                },
+            };
+        }));
+        return nextWithObject(lastValue, {
+            [code]: {
+                headers,
+                content,
+            },
+        });
+    }));
+    return utils.A.map(route.definition.paths, (path) => ({
+        path,
+        method: methodMapper[route.definition.method],
+        parameters,
+        requestBody,
+        responses,
+    }));
+}
+
+exports.routeToOpenApi = routeToOpenApi;

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

@@ -0,0 +1,35 @@
+import type { Route } from "../../core/route";
+import type { ResponseCode, ResponseContract } from "../../core/response";
+import { type MapContext, type JsonSchema } from "@duplojs/data-parser-tools/toJsonSchema";
+import type { EndpointResponse, EntrypointParameter } from "./types";
+export type ResultSchemaContext = Map<string, Record<string, JsonSchema>>;
+export interface RouteToOpenApiParams {
+    readonly contextToJsonSchemaFactory: MapContext;
+    readonly resultSchemaContext: ResultSchemaContext;
+    readonly defaultExtractContract: ResponseContract.Contract;
+}
+export declare function routeToOpenApi(route: Route, params: RouteToOpenApiParams): {
+    path: `/${string}`;
+    method: "options" | "get" | "post" | "put" | "delete" | "head" | "trace" | "connect";
+    parameters: EntrypointParameter[];
+    requestBody: {
+        required: true;
+        content: {
+            "application/json": {
+                schema: {
+                    $ref: `#/components/schemas/${string}`;
+                };
+            };
+        };
+    } | {
+        required: true;
+        content: {
+            "text/plain": {
+                schema: {
+                    $ref: `#/components/schemas/${string}`;
+                };
+            };
+        };
+    } | undefined;
+    responses: Partial<Record<ResponseCode, EndpointResponse>>;
+}[];

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -0,0 +1,161 @@
+import { aggregateStepContract } from './aggregateStepContract.mjs';
+import { O, pipe, A, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
+import { render, defaultTransformers } from '@duplojs/data-parser-tools/toJsonSchema';
+
+function factoryJsonSchema(params) {
+    const identifier = params.schema.definition.identifier
+        ?? `NotIdentified${params.resultSchemaContext.size}`;
+    const renderResult = render(params.schema, {
+        identifier,
+        mode: params.mode,
+        context: params.context,
+        version: "openApi31",
+        transformers: defaultTransformers,
+    });
+    params.resultSchemaContext.set(identifier, renderResult.components.schemas);
+    return O.pick(renderResult, { $ref: true });
+}
+const parameterKeyMapper = {
+    query: "query",
+    params: "path",
+    headers: "header",
+};
+const methodMapper = {
+    GET: "get",
+    POST: "post",
+    PUT: "put",
+    DELETE: "delete",
+    HEAD: "head",
+    TRACE: "trace",
+    CONNECT: "connect",
+    OPTIONS: "options",
+};
+function routeToOpenApi(route, params) {
+    const aggregateStepResult = aggregateStepContract([
+        ...route.definition.preflightSteps,
+        ...route.definition.steps,
+    ], {
+        defaultExtractContract: params.defaultExtractContract,
+    });
+    const { body, ...restEntrypoint } = aggregateStepResult.entrypointContract;
+    const parameters = pipe(restEntrypoint, O.entries, A.select(({ element: [key, value], select, skip }) => !DP.dataParserKind.has(value) && O.countKeys(value)
+        ? select(O.entry(key, O.entries(value)))
+        : skip()), A.flatMap(([key, value]) => A.map(value, ([name, schema]) => ({
+        name,
+        in: parameterKeyMapper[key],
+        required: !DP.identifier(schema, DP.optionalKind),
+        schema: factoryJsonSchema({
+            context: params.contextToJsonSchemaFactory,
+            resultSchemaContext: params.resultSchemaContext,
+            mode: "in",
+            schema,
+        }),
+    }))));
+    const requestBody = pipe(body, when((value) => O.countKeys(value) === 0, justReturn(DP.empty())), whenNot(DP.dataParserKind.has, DP.object), P.when(DP.identifier(DP.emptyKind), justReturn(undefined)), P.when(DP.identifier(DP.objectKind), (objectSchema) => ({
+        required: true,
+        content: {
+            "application/json": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), P.otherwise((primitiveSchema) => ({
+        required: true,
+        content: {
+            "text/plain": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: primitiveSchema,
+                }),
+            },
+        },
+    })));
+    const responses = pipe(aggregateStepResult.endpointContract, A.reduce(A.reduceFrom({}), ({ lastValue, element: { information, body, code }, nextWithObject }) => {
+        const schemaResponse = !DP.identifier(body, DP.emptyKind)
+            ? factoryJsonSchema({
+                context: params.contextToJsonSchemaFactory,
+                resultSchemaContext: params.resultSchemaContext,
+                mode: "in",
+                schema: body,
+            })
+            : undefined;
+        const headerInformation = {
+            const: information,
+            type: "string",
+        };
+        const headerDescription = P.match(lastValue[code])
+            .when(isType("object"), (value) => {
+            if (S.includes(value.headers.information.description, information)) {
+                return value.headers.information.description;
+            }
+            return S.concat(value.headers.information.description, " | ", information);
+        })
+            .when(isType("undefined"), justReturn(information))
+            .exhaustive();
+        const headers = {
+            information: {
+                schema: lastValue[code]
+                    ? {
+                        anyOf: [
+                            lastValue[code].headers.information.schema,
+                            headerInformation,
+                        ],
+                    }
+                    : headerInformation,
+                description: headerDescription,
+            },
+        };
+        const content = pipe(body, P.when(DP.identifier(DP.emptyKind), justReturn(lastValue[code]?.content)), P.otherwise((value) => {
+            if (DP.identifier(value, DP.stringKind) && lastValue[code]?.content?.["plain/text"]) {
+                return lastValue[code].content;
+            }
+            if (DP.identifier(value, DP.stringKind)) {
+                return {
+                    ...lastValue[code]?.content,
+                    "plain/text": {
+                        schema: schemaResponse,
+                    },
+                };
+            }
+            if (DP.identifier(value, DP.objectKind) && lastValue[code]?.content?.["application/json"]) {
+                return {
+                    ...lastValue[code]?.content,
+                    "application/json": {
+                        schema: {
+                            anyOf: [
+                                lastValue[code].content["application/json"].schema,
+                                schemaResponse,
+                            ],
+                        },
+                    },
+                };
+            }
+            return {
+                "application/json": {
+                    schema: schemaResponse,
+                },
+            };
+        }));
+        return nextWithObject(lastValue, {
+            [code]: {
+                headers,
+                content,
+            },
+        });
+    }));
+    return A.map(route.definition.paths, (path) => ({
+        path,
+        method: methodMapper[route.definition.method],
+        parameters,
+        requestBody,
+        responses,
+    }));
+}
+
+export { routeToOpenApi };

package/dist/plugins/openApiGenerator/types/endpointResponse.cjs

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

package/dist/plugins/openApiGenerator/types/endpointResponse.d.ts

@@ -0,0 +1,19 @@
+import type { JsonSchema, JsonSchemaLiteral, JsonSchemaString } from "@duplojs/data-parser-tools/toJsonSchema";
+export interface EndpointResponseHeader {
+    information: {
+        schema: JsonSchemaLiteral;
+        description: string;
+    };
+}
+export interface EndpointResponseContent {
+    "application/json"?: {
+        schema: JsonSchema;
+    };
+    "plain/text"?: {
+        schema: JsonSchemaString;
+    };
+}
+export interface EndpointResponse {
+    headers: EndpointResponseHeader;
+    content?: EndpointResponseContent;
+}

package/dist/plugins/openApiGenerator/types/endpointResponse.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/openApiGenerator/types/entrypoint.cjs

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

package/dist/plugins/openApiGenerator/types/entrypoint.d.ts

@@ -0,0 +1,22 @@
+import type { JsonSchema } from "@duplojs/data-parser-tools/toJsonSchema";
+export interface EntrypointParameter {
+    name: string;
+    in: "path" | "query" | "header";
+    required: boolean;
+    schema: JsonSchema;
+}
+export interface EntrypointContentBodyApplicationJson {
+    "application/json": {
+        schema: JsonSchema;
+    };
+}
+export interface EntrypointContentBodyTextPlain {
+    "text/plain": {
+        schema: JsonSchema;
+    };
+}
+export type EntrypointContentBody = EntrypointContentBodyApplicationJson | EntrypointContentBodyTextPlain;
+export interface EntrypointRequestBody {
+    required: true;
+    content: EntrypointContentBody;
+}

package/dist/plugins/openApiGenerator/types/entrypoint.mjs

@@ -0,0 +1 @@
+

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

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

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,11 @@
+'use strict';
+
+require('./entrypointKey.cjs');
+require('./openApiMethod.cjs');
+require('./entrypoint.cjs');
+require('./openApiSecuritySchema.cjs');
+require('./endpointResponse.cjs');
+require('./openApiOperation.cjs');
+require('./openApiPath.cjs');
+require('./openApiDocument.cjs');
+

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

@@ -0,0 +1,8 @@
+export * from "./entrypointKey";
+export * from "./openApiMethod";
+export * from "./entrypoint";
+export * from "./openApiSecuritySchema";
+export * from "./endpointResponse";
+export * from "./openApiOperation";
+export * from "./openApiPath";
+export * from "./openApiDocument";

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

@@ -0,0 +1,8 @@
+import './entrypointKey.mjs';
+import './openApiMethod.mjs';
+import './entrypoint.mjs';
+import './openApiSecuritySchema.mjs';
+import './endpointResponse.mjs';
+import './openApiOperation.mjs';
+import './openApiPath.mjs';
+import './openApiDocument.mjs';

package/dist/plugins/openApiGenerator/types/openApiDocument.cjs

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

package/dist/plugins/openApiGenerator/types/openApiDocument.d.ts

@@ -0,0 +1,31 @@
+import type { JsonSchema } from "@duplojs/data-parser-tools/toJsonSchema";
+import type { OpenApiSecuritySchema } from "./openApiSecuritySchema";
+import type { OpenApiPath } from "./openApiPath";
+export interface OpenApiDocument {
+    openapi: "3.1.0";
+    info: {
+        title: string;
+        version: string;
+        summary?: string;
+        contact?: {
+            name?: string;
+            email?: string;
+            url?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+            identifier?: string;
+        };
+    };
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    paths: OpenApiPath;
+    components: {
+        schemas: Record<string, JsonSchema>;
+        securitySchemes?: Record<string, OpenApiSecuritySchema>;
+    };
+    security?: Record<string, string[]>[];
+}

package/dist/plugins/openApiGenerator/types/openApiDocument.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/openApiGenerator/types/openApiMethod.cjs

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

package/dist/plugins/openApiGenerator/types/openApiMethod.d.ts

@@ -0,0 +1 @@
+export type OpenApiMethod = "get" | "post" | "put" | "delete" | "head" | "trace" | "connect" | "options";

package/dist/plugins/openApiGenerator/types/openApiMethod.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/openApiGenerator/types/openApiOperation.cjs

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

package/dist/plugins/openApiGenerator/types/openApiOperation.d.ts

@@ -0,0 +1,8 @@
+import type { ResponseCode } from "../../../core/response";
+import type { EntrypointParameter, EntrypointRequestBody } from "./entrypoint";
+import type { EndpointResponse } from "./endpointResponse";
+export interface OpenApiOperation {
+    parameters?: EntrypointParameter[];
+    requestBody?: EntrypointRequestBody;
+    responses: Partial<Record<ResponseCode, EndpointResponse>>;
+}

package/dist/plugins/openApiGenerator/types/openApiOperation.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/openApiGenerator/types/openApiPath.cjs

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