@duplojs/http 0.6.1 → 0.7.0

package/dist/interfaces/node/hooks/index.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+require('../../../core/route/index.cjs');
+var serverUtils = require('@duplojs/server-utils');
+var utils = require('@duplojs/utils');
+var node_fs = require('node:fs');
+var hooks = require('../../../core/route/hooks.cjs');
+
+const nodeHook = hooks.createHookRouteLifeCycle({
+    beforeSendResponse({ request, currentResponse, exit }) {
+        request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+        return exit();
+    },
+    async sendResponse({ request, currentResponse, exit }) {
+        const { response: rawResponse } = request.raw;
+        const body = currentResponse.body;
+        if (body instanceof Error) {
+            rawResponse.write(body.toString());
+        }
+        else if (serverUtils.SF.isFileInterface(body)) {
+            await new Promise((resolve, reject) => {
+                node_fs.createReadStream(body.path)
+                    .pipe(request.raw.response
+                    .once("error", reject)
+                    .once("close", resolve));
+            });
+        }
+        else if (typeof body === "object"
+            || typeof body === "number"
+            || typeof body === "boolean") {
+            rawResponse.write(JSON.stringify(body));
+        }
+        else if (typeof body === "string") {
+            rawResponse.write(body);
+        }
+        rawResponse.end();
+        return exit();
+    },
+    async afterSendResponse({ request, next }) {
+        if (request.filesAttache) {
+            await Promise.all(utils.A.map(request.filesAttache, (path) => serverUtils.SF.remove(path)));
+        }
+        return next();
+    },
+});
+
+exports.nodeHook = nodeHook;

package/dist/interfaces/node/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export declare const nodeHook: {
+    beforeSendResponse({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): import("../../../core/route").RouteHookExit;
+    sendResponse({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): Promise<import("../../../core/route").RouteHookExit>;
+    afterSendResponse({ request, next }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): Promise<import("../../../core/route").RouteHookNext>;
+};

package/dist/interfaces/node/hooks/index.mjs

@@ -0,0 +1,45 @@
+import '../../../core/route/index.mjs';
+import { SF } from '@duplojs/server-utils';
+import { A } from '@duplojs/utils';
+import { createReadStream } from 'node:fs';
+import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
+
+const nodeHook = createHookRouteLifeCycle({
+    beforeSendResponse({ request, currentResponse, exit }) {
+        request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+        return exit();
+    },
+    async sendResponse({ request, currentResponse, exit }) {
+        const { response: rawResponse } = request.raw;
+        const body = currentResponse.body;
+        if (body instanceof Error) {
+            rawResponse.write(body.toString());
+        }
+        else if (SF.isFileInterface(body)) {
+            await new Promise((resolve, reject) => {
+                createReadStream(body.path)
+                    .pipe(request.raw.response
+                    .once("error", reject)
+                    .once("close", resolve));
+            });
+        }
+        else if (typeof body === "object"
+            || typeof body === "number"
+            || typeof body === "boolean") {
+            rawResponse.write(JSON.stringify(body));
+        }
+        else if (typeof body === "string") {
+            rawResponse.write(body);
+        }
+        rawResponse.end();
+        return exit();
+    },
+    async afterSendResponse({ request, next }) {
+        if (request.filesAttache) {
+            await Promise.all(A.map(request.filesAttache, (path) => SF.remove(path)));
+        }
+        return next();
+    },
+});
+
+export { nodeHook };

package/dist/interfaces/node/index.cjs

@@ -2,18 +2,22 @@
 
 require('./types/index.cjs');
 var kind = require('./kind.cjs');
-require('./error/index.cjs');
 var createHttpServer = require('./createHttpServer.cjs');
-var hooks = require('./hooks.cjs');
-var bodySizeExceedsLimitError = require('./error/bodySizeExceedsLimitError.cjs');
-var bodyParseWrongChunkReceived = require('./error/bodyParseWrongChunkReceived.cjs');
-var bodyParseUnknownError = require('./error/bodyParseUnknownError.cjs');
+var index = require('./hooks/index.cjs');
+require('./bodyReaders/index.cjs');
+var error = require('./bodyReaders/formData/error.cjs');
+var readRequestFormData = require('./bodyReaders/formData/readRequestFormData.cjs');
+var index$1 = require('./bodyReaders/formData/index.cjs');
+var readRequestText = require('./bodyReaders/text/readRequestText.cjs');
+var index$2 = require('./bodyReaders/text/index.cjs');
 
 
 
 exports.createInterfacesNodeLibKind = kind.createInterfacesNodeLibKind;
 exports.createHttpServer = createHttpServer.createHttpServer;
-exports.makeNodeHook = hooks.makeNodeHook;
-exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
-exports.BodyParseWrongChunkReceived = bodyParseWrongChunkReceived.BodyParseWrongChunkReceived;
-exports.BodyParseUnknownError = bodyParseUnknownError.BodyParseUnknownError;
+exports.nodeHook = index.nodeHook;
+exports.BodyParseFormDataError = error.BodyParseFormDataError;
+exports.readRequestFormData = readRequestFormData.readRequestFormData;
+exports.createFormDataBodyReaderImplementation = index$1.createFormDataBodyReaderImplementation;
+exports.readRequestText = readRequestText.readRequestText;
+exports.createTextBodyReaderImplementation = index$2.createTextBodyReaderImplementation;

package/dist/interfaces/node/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./types";
 export * from "./kind";
-export * from "./error";
 export * from "./createHttpServer";
 export * from "./hooks";
+export * from "./bodyReaders";

package/dist/interfaces/node/index.mjs

@@ -1,8 +1,10 @@
 import './types/index.mjs';
 export { createInterfacesNodeLibKind } from './kind.mjs';
-import './error/index.mjs';
 export { createHttpServer } from './createHttpServer.mjs';
-export { makeNodeHook } from './hooks.mjs';
-export { BodySizeExceedsLimitError } from './error/bodySizeExceedsLimitError.mjs';
-export { BodyParseWrongChunkReceived } from './error/bodyParseWrongChunkReceived.mjs';
-export { BodyParseUnknownError } from './error/bodyParseUnknownError.mjs';
+export { nodeHook } from './hooks/index.mjs';
+import './bodyReaders/index.mjs';
+export { BodyParseFormDataError } from './bodyReaders/formData/error.mjs';
+export { readRequestFormData } from './bodyReaders/formData/readRequestFormData.mjs';
+export { createFormDataBodyReaderImplementation } from './bodyReaders/formData/index.mjs';
+export { readRequestText } from './bodyReaders/text/readRequestText.mjs';
+export { createTextBodyReaderImplementation } from './bodyReaders/text/index.mjs';

package/dist/interfaces/node/types/index.cjs

@@ -1,5 +1,4 @@
 'use strict';
 
-require('./host.cjs');
 require('./request.cjs');
 

package/dist/interfaces/node/types/index.d.ts

@@ -1,2 +1 @@
-export * from "./host";
 export * from "./request";

package/dist/interfaces/node/types/index.mjs

@@ -1,2 +1 @@
-import './host.mjs';
 import './request.mjs';

package/dist/interfaces/node/types/request.cjs

@@ -1,5 +1,5 @@
 'use strict';
 
-require('../../../core/request.cjs');
+require('../../../core/request/index.cjs');
 require('../../../core/steps/index.cjs');
 

package/dist/interfaces/node/types/request.mjs

@@ -1,2 +1,2 @@
-import '../../../core/request.mjs';
+import '../../../core/request/index.mjs';
 import '../../../core/steps/index.mjs';

package/dist/plugins/codeGenerator/index.cjs

@@ -10,6 +10,8 @@ var metadata = require('./metadata.cjs');
 
 
 exports.codeGeneratorPlugin = plugin.codeGeneratorPlugin;
+exports.bodyAsFormData = routeToDataParser.bodyAsFormData;
+exports.convertRoutePath = routeToDataParser.convertRoutePath;
 exports.routeToDataParser = routeToDataParser.routeToDataParser;
 exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
 exports.IgnoreByCodeGeneratorMetadata = metadata.IgnoreByCodeGeneratorMetadata;

package/dist/plugins/codeGenerator/index.mjs

@@ -1,6 +1,6 @@
 import '@duplojs/data-parser-tools/toTypescript';
 import './types/index.mjs';
 export { codeGeneratorPlugin } from './plugin.mjs';
-export { routeToDataParser } from './routeToDataParser.mjs';
+export { bodyAsFormData, convertRoutePath, routeToDataParser } from './routeToDataParser.mjs';
 export { aggregateStepContract } from './aggregateStepContract.mjs';
 export { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';

package/dist/plugins/codeGenerator/plugin.cjs

@@ -3,7 +3,8 @@
 var DataParserToTypescript = require('@duplojs/data-parser-tools/toTypescript');
 var utils = require('@duplojs/utils');
 var routeToDataParser = require('./routeToDataParser.cjs');
-var promises = require('node:fs/promises');
+var serverUtils = require('@duplojs/server-utils');
+var typescriptTransfomer = require('./typescriptTransfomer.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -33,7 +34,7 @@ function codeGeneratorPlugin(pluginParams) {
                     if (!utils.equal(hub.config.environment, ["DEV", "BUILD"])) {
                         return;
                     }
-                    const routes = hub.aggregatesRoutes();
+                    const routes = utils.A.from(hub.routes);
                     const dataParserRoutes = utils.A.flatMap(routes, (route) => routeToDataParser.routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
@@ -42,9 +43,12 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript__namespace.render(utils.DP.union(dataParserRoutes), {
                         identifier: "Routes",
-                        transformers: DataParserToTypescript__namespace.defaultTransformers,
+                        transformers: [
+                            typescriptTransfomer.fileTransformer,
+                            ...DataParserToTypescript__namespace.defaultTransformers,
+                        ],
                     });
-                    await promises.writeFile(pluginParams.outputFile, output);
+                    utils.asserts(await serverUtils.SF.writeTextFile(pluginParams.outputFile, output), utils.E.isRight);
                 },
             },
         ],

package/dist/plugins/codeGenerator/plugin.mjs

@@ -1,7 +1,8 @@
 import * as DataParserToTypescript from '@duplojs/data-parser-tools/toTypescript';
-import { equal, A, DP } from '@duplojs/utils';
+import { equal, A, DP, asserts, E } from '@duplojs/utils';
 import { routeToDataParser } from './routeToDataParser.mjs';
-import { writeFile } from 'node:fs/promises';
+import { SF } from '@duplojs/server-utils';
+import { fileTransformer } from './typescriptTransfomer.mjs';
 
 function codeGeneratorPlugin(pluginParams) {
     return () => ({
@@ -12,7 +13,7 @@ function codeGeneratorPlugin(pluginParams) {
                     if (!equal(hub.config.environment, ["DEV", "BUILD"])) {
                         return;
                     }
-                    const routes = hub.aggregatesRoutes();
+                    const routes = A.from(hub.routes);
                     const dataParserRoutes = A.flatMap(routes, (route) => routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
@@ -21,9 +22,12 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript.render(DP.union(dataParserRoutes), {
                         identifier: "Routes",
-                        transformers: DataParserToTypescript.defaultTransformers,
+                        transformers: [
+                            fileTransformer,
+                            ...DataParserToTypescript.defaultTransformers,
+                        ],
                     });
-                    await writeFile(pluginParams.outputFile, output);
+                    asserts(await SF.writeTextFile(pluginParams.outputFile, output), E.isRight);
                 },
             },
         ],

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -3,7 +3,21 @@
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
 var metadata = require('./metadata.cjs');
+require('../../core/request/index.cjs');
+var typescript = require('typescript');
+var formData = require('../../core/request/bodyController/formData.cjs');
 
+const bodyAsFormData = (dataParser, { transformer, success, addImport }) => {
+    const result = transformer(dataParser);
+    if (utils.E.isLeft(result)) {
+        return result;
+    }
+    addImport("@duplojs/utils", "TheFormData");
+    return success(typescript.factory.createTypeReferenceNode("TheFormData", [utils.unwrap(result)]));
+};
+const convertRoutePath = (path) => utils.pipe(path, utils.S.split("*"), utils.A.flatMap((element, { index, self }) => utils.A.isLastIndex(self, index)
+    ? element
+    : [element, utils.DP.string()]), utils.P.when(utils.A.minElements(2), (template) => utils.DP.templateLiteral(template)), utils.P.otherwise(() => utils.DP.literal(path)));
 function routeToDataParser(route, params) {
     const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is);
     if (isIgnore) {
@@ -24,10 +38,19 @@ function routeToDataParser(route, params) {
         return skip();
     }), utils.O.fromEntries)), ({ endpointContract, entrypointContract }) => utils.A.map(route.definition.paths, (path) => utils.DP.object({
         method: utils.DP.literal(route.definition.method),
-        path: utils.DP.literal(path),
+        path: convertRoutePath(path),
         ...entrypointContract,
+        ...(entrypointContract.body && formData.FormDataBodyController.is(route.definition.bodyController)
+            ? {
+                body: entrypointContract
+                    .body
+                    .addOverrideTypescriptTransformer(bodyAsFormData),
+            }
+            : {}),
         responses: utils.DP.union(endpointContract),
     })));
 }
 
+exports.bodyAsFormData = bodyAsFormData;
+exports.convertRoutePath = convertRoutePath;
 exports.routeToDataParser = routeToDataParser;

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

@@ -1,7 +1,41 @@
 import { type Route } from "../../core/route";
 import { DP } from "@duplojs/utils";
 import { type ResponseContract } from "../../core/response";
+import { type TransformerBuildFunction } from "@duplojs/data-parser-tools/toTypescript";
 export interface RouteToDataParserParams {
     readonly defaultExtractContract: ResponseContract.Contract;
 }
+export declare const bodyAsFormData: TransformerBuildFunction;
+export declare const convertRoutePath: (path: string) => DP.DataParserLiteral<{
+    readonly value: readonly string[];
+    readonly errorMessage?: string | undefined;
+    readonly identifier?: string | undefined;
+    readonly overrideTypescriptTransformer?: TransformerBuildFunction | undefined;
+    readonly checkers: readonly [];
+}> | DP.DataParserTemplateLiteral<{
+    readonly template: [string | DP.DataParserString<{
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly overrideTypescriptTransformer?: TransformerBuildFunction | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>, string | DP.DataParserString<{
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly overrideTypescriptTransformer?: TransformerBuildFunction | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>, ...(string | DP.DataParserString<{
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly overrideTypescriptTransformer?: TransformerBuildFunction | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>)[]];
+    readonly errorMessage?: string | undefined;
+    readonly identifier?: string | undefined;
+    readonly overrideTypescriptTransformer?: TransformerBuildFunction | undefined;
+    readonly pattern: RegExp;
+    readonly checkers: readonly [];
+}>;
 export declare function routeToDataParser(route: Route, params: RouteToDataParserParams): DP.DataParser[];

package/dist/plugins/codeGenerator/routeToDataParser.mjs

@@ -1,7 +1,21 @@
 import { aggregateStepContract } from './aggregateStepContract.mjs';
-import { A, pipe, O, innerPipe, DP } from '@duplojs/utils';
+import { E, unwrap, pipe, S, A, DP, P, O, innerPipe } from '@duplojs/utils';
 import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
+import '../../core/request/index.mjs';
+import { factory } from 'typescript';
+import { FormDataBodyController } from '../../core/request/bodyController/formData.mjs';
 
+const bodyAsFormData = (dataParser, { transformer, success, addImport }) => {
+    const result = transformer(dataParser);
+    if (E.isLeft(result)) {
+        return result;
+    }
+    addImport("@duplojs/utils", "TheFormData");
+    return success(factory.createTypeReferenceNode("TheFormData", [unwrap(result)]));
+};
+const convertRoutePath = (path) => pipe(path, S.split("*"), A.flatMap((element, { index, self }) => A.isLastIndex(self, index)
+    ? element
+    : [element, DP.string()]), P.when(A.minElements(2), (template) => DP.templateLiteral(template)), P.otherwise(() => DP.literal(path)));
 function routeToDataParser(route, params) {
     const isIgnore = A.find(route.definition.metadata, IgnoreByCodeGeneratorMetadata.is);
     if (isIgnore) {
@@ -22,10 +36,17 @@ function routeToDataParser(route, params) {
         return skip();
     }), O.fromEntries)), ({ endpointContract, entrypointContract }) => A.map(route.definition.paths, (path) => DP.object({
         method: DP.literal(route.definition.method),
-        path: DP.literal(path),
+        path: convertRoutePath(path),
         ...entrypointContract,
+        ...(entrypointContract.body && FormDataBodyController.is(route.definition.bodyController)
+            ? {
+                body: entrypointContract
+                    .body
+                    .addOverrideTypescriptTransformer(bodyAsFormData),
+            }
+            : {}),
         responses: DP.union(endpointContract),
     })));
 }
 
-export { routeToDataParser };
+export { bodyAsFormData, convertRoutePath, routeToDataParser };

package/dist/plugins/codeGenerator/typescriptTransfomer.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var DataParserToTypescript = require('@duplojs/data-parser-tools/toTypescript');
+var serverUtils = require('@duplojs/server-utils');
+var typescript = require('typescript');
+
+const fileTransformer = DataParserToTypescript.createTransformer(serverUtils.SDP.fileKind.has, (__, { success }) => success(typescript.factory.createTypeReferenceNode("File")));
+
+exports.fileTransformer = fileTransformer;

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

@@ -0,0 +1 @@
+export declare const fileTransformer: (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;

package/dist/plugins/codeGenerator/typescriptTransfomer.mjs

@@ -0,0 +1,7 @@
+import { createTransformer } from '@duplojs/data-parser-tools/toTypescript';
+import { SDP } from '@duplojs/server-utils';
+import { factory } from 'typescript';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (__, { success }) => success(factory.createTypeReferenceNode("File")));
+
+export { fileTransformer };

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

@@ -7,10 +7,13 @@ export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: stri
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];
+    readonly bodyController: null;
     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 overrideJsonSchemaTransformer?: import("@duplojs/data-parser-tools/toJsonSchema").TransformerBuildFunction | undefined;
+            readonly overrideTypescriptTransformer?: import("@duplojs/data-parser-tools/toTypescript").TransformerBuildFunction | undefined;
             readonly coerce: boolean;
             readonly checkers: readonly [];
         }>>>;

package/dist/plugins/openApiGenerator/plugin.cjs

@@ -4,7 +4,7 @@ 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');
+var serverUtils = require('@duplojs/server-utils');
 
 function openApiGeneratorPlugin(pluginParams) {
     return () => ({
@@ -19,7 +19,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
-                    const routes = hub.aggregatesRoutes();
+                    const routes = utils.A.from(hub.routes);
                     const openApiRoutes = utils.pipe(routes, utils.A.filter((route) => route.definition.method !== "OPTIONS"), utils.A.flatMap((route) => routeToOpenApi.routeToOpenApi(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                         resultSchemaContext,
@@ -77,7 +77,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
                     if (pluginParams.outputFile) {
-                        await promises.writeFile(pluginParams.outputFile, openApiDocumentString);
+                        utils.asserts(await serverUtils.SF.writeTextFile(pluginParams.outputFile, openApiDocumentString), utils.E.isRight);
                     }
                     if (pluginParams.routePath) {
                         const openApiPage = makeOpenApiPage.makeOpenApiPage({

package/dist/plugins/openApiGenerator/plugin.mjs

@@ -1,8 +1,8 @@
 import { routeToOpenApi } from './routeToOpenApi.mjs';
-import { equal, pipe, A, O, G, P, justReturn } from '@duplojs/utils';
+import { equal, A, pipe, O, G, P, justReturn, asserts, E } from '@duplojs/utils';
 import { makeOpenApiPage } from './makeOpenApiPage.mjs';
 import { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
-import { writeFile } from 'fs/promises';
+import { SF } from '@duplojs/server-utils';
 
 function openApiGeneratorPlugin(pluginParams) {
     return () => ({
@@ -17,7 +17,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
-                    const routes = hub.aggregatesRoutes();
+                    const routes = A.from(hub.routes);
                     const openApiRoutes = pipe(routes, A.filter((route) => route.definition.method !== "OPTIONS"), A.flatMap((route) => routeToOpenApi(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                         resultSchemaContext,
@@ -75,7 +75,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
                     if (pluginParams.outputFile) {
-                        await writeFile(pluginParams.outputFile, openApiDocumentString);
+                        asserts(await SF.writeTextFile(pluginParams.outputFile, openApiDocumentString), E.isRight);
                     }
                     if (pluginParams.routePath) {
                         const openApiPage = makeOpenApiPage({

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -3,7 +3,9 @@
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
 var toJsonSchema = require('@duplojs/data-parser-tools/toJsonSchema');
+require('../../core/request/index.cjs');
 var metadata = require('./metadata.cjs');
+var formData = require('../../core/request/bodyController/formData.cjs');
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -32,6 +34,7 @@ const methodMapper = {
     TRACE: "trace",
     CONNECT: "connect",
     OPTIONS: "options",
+    PATCH: "patch",
 };
 function routeToOpenApi(route, params) {
     const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is);
@@ -58,7 +61,19 @@ function routeToOpenApi(route, params) {
             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) => ({
+    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(() => formData.FormDataBodyController.is(route.definition.bodyController), (objectSchema) => ({
+        required: true,
+        content: {
+            "multipart/form-data": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), utils.P.when(utils.DP.identifier(utils.DP.objectKind), (objectSchema) => ({
         required: true,
         content: {
             "application/json": {

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

@@ -10,9 +10,18 @@ export interface RouteToOpenApiParams {
 }
 export declare function routeToOpenApi(route: Route, params: RouteToOpenApiParams): {
     path: `/${string}`;
-    method: "options" | "get" | "post" | "put" | "delete" | "head" | "trace" | "connect";
+    method: "options" | "get" | "post" | "put" | "patch" | "delete" | "head" | "trace" | "connect";
     parameters: EntrypointParameter[];
     requestBody: {
+        required: true;
+        content: {
+            "multipart/form-data": {
+                schema: {
+                    $ref: `#/components/schemas/${string}`;
+                };
+            };
+        };
+    } | {
         required: true;
         content: {
             "application/json": {

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -1,7 +1,9 @@
 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 '../../core/request/index.mjs';
 import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
+import { FormDataBodyController } from '../../core/request/bodyController/formData.mjs';
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -30,6 +32,7 @@ const methodMapper = {
     TRACE: "trace",
     CONNECT: "connect",
     OPTIONS: "options",
+    PATCH: "patch",
 };
 function routeToOpenApi(route, params) {
     const isIgnore = A.find(route.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is);
@@ -56,7 +59,19 @@ function routeToOpenApi(route, params) {
             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) => ({
+    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(() => FormDataBodyController.is(route.definition.bodyController), (objectSchema) => ({
+        required: true,
+        content: {
+            "multipart/form-data": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    mode: "in",
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), P.when(DP.identifier(DP.objectKind), (objectSchema) => ({
         required: true,
         content: {
             "application/json": {

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

@@ -10,12 +10,17 @@ export interface EntrypointContentBodyApplicationJson {
         schema: JsonSchema;
     };
 }
+export interface EntrypointContentBodyFormData {
+    "multipart/form-data": {
+        schema: JsonSchema;
+    };
+}
 export interface EntrypointContentBodyTextPlain {
     "text/plain": {
         schema: JsonSchema;
     };
 }
-export type EntrypointContentBody = EntrypointContentBodyApplicationJson | EntrypointContentBodyTextPlain;
+export type EntrypointContentBody = (EntrypointContentBodyApplicationJson | EntrypointContentBodyTextPlain | EntrypointContentBodyFormData);
 export interface EntrypointRequestBody {
     required: true;
     content: EntrypointContentBody;

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

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