@duplojs/http 0.2.0 → 0.5.0

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+var aggregateStepContract = require('./aggregateStepContract.cjs');
+var utils = require('@duplojs/utils');
+var toJsonSchema = require('@duplojs/data-parser-tools/toJsonSchema');
+var metadata = require('./metadata.cjs');
+
+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 isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
+    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,166 @@
+import { aggregateStepContract } from './aggregateStepContract.mjs';
+import { O, A, pipe, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
+import { render, defaultTransformers } from '@duplojs/data-parser-tools/toJsonSchema';
+import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
+
+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 isIgnore = A.find(route.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
+    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';
+

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

@@ -0,0 +1,4 @@
+import type { RoutePath } from "../../../core/route";
+import type { OpenApiMethod } from "./openApiMethod";
+import type { OpenApiOperation } from "./openApiOperation";
+export type OpenApiPath = Record<RoutePath, Partial<Record<OpenApiMethod, OpenApiOperation>> | undefined>;

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,8 @@
+export type SupportedBearerFormat = "JWT" | "JWS" | "JWE" | "Opaque";
+export interface OpenApiSecuritySchema {
+    type: "http" | "apiKey";
+    scheme?: "bearer" | "basic";
+    bearerFormat?: SupportedBearerFormat;
+    name?: string;
+    in?: "header" | "query" | "cookie";
+}

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

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -14,7 +14,7 @@
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json",
+    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types",
     "test:lint": "eslint",
     "test:lint:fix": "eslint --fix",
     "prepare": "husky"
@@ -26,6 +26,11 @@
       "require": "./dist/core/index.cjs",
       "types": "./dist/core/index.d.ts"
     },
+    "./client": {
+      "import": "./dist/client/index.mjs",
+      "require": "./dist/client/index.cjs",
+      "types": "./dist/client/index.d.ts"
+    },
     "./node": {
       "import": "./dist/interfaces/node/index.mjs",
       "require": "./dist/interfaces/node/index.cjs",
@@ -45,6 +50,11 @@
       "import": "./dist/plugins/codeGenerator/index.mjs",
       "require": "./dist/plugins/codeGenerator/index.cjs",
       "types": "./dist/plugins/codeGenerator/index.d.ts"
+    },
+    "./openApiGenerator": {
+      "import": "./dist/plugins/openApiGenerator/index.mjs",
+      "require": "./dist/plugins/openApiGenerator/index.cjs",
+      "types": "./dist/plugins/openApiGenerator/index.d.ts"
     }
   },
   "files": [
@@ -52,8 +62,8 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@duplojs/data-parser-tools": ">=0.2.2 <1.0.0",
-    "@duplojs/utils": ">=1.3.32 <2.0.0"
+    "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
+    "@duplojs/utils": ">=1.4.40 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -84,5 +94,8 @@
   "keywords": [],
   "engines": {
     "node": ">=22.15.1"
+  },
+  "dependencies": {
+    "@types/web": "^0.0.317"
   }
 }