@duplojs/http 0.6.2 → 0.7.1

package/dist/interfaces/node/bodyReaders/text/readRequestText.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+require('../../../../core/errors/index.cjs');
+var utils = require('@duplojs/utils');
+var bodyParseWrongChunkReceived = require('../../../../core/errors/bodyParseWrongChunkReceived.cjs');
+var bodySizeExceedsLimitError = require('../../../../core/errors/bodySizeExceedsLimitError.cjs');
+
+async function readRequestText(request, params, onEnd) {
+    let result = "";
+    let size = 0;
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                return utils.E.error(new bodyParseWrongChunkReceived.BodyParseWrongChunkReceived("Buffer or String.", chunk));
+            }
+            size += chunk instanceof Buffer
+                ? chunk.byteLength
+                : Buffer.byteLength(chunk);
+            if (size > params.maxBodySize) {
+                return utils.E.error(new bodySizeExceedsLimitError.BodySizeExceedsLimitError(params.maxBodySize));
+            }
+            result += chunk.toString();
+        }
+        if (onEnd) {
+            return await onEnd(result);
+        }
+        return result;
+    }
+    catch (error) {
+        return utils.E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+exports.readRequestText = readRequestText;

package/dist/interfaces/node/bodyReaders/text/readRequestText.d.ts

@@ -0,0 +1,6 @@
+import { E } from "@duplojs/utils";
+import type http from "http";
+export interface ReadRequestTextParams {
+    maxBodySize: number;
+}
+export declare function readRequestText<GenericOutputValue extends unknown = string>(request: http.IncomingMessage, params: ReadRequestTextParams, onEnd?: (result: string) => GenericOutputValue): Promise<E.Left<"server-error", unknown> | E.Error<Error> | GenericOutputValue>;

package/dist/interfaces/node/bodyReaders/text/readRequestText.mjs

@@ -0,0 +1,35 @@
+import '../../../../core/errors/index.mjs';
+import { E } from '@duplojs/utils';
+import { BodyParseWrongChunkReceived } from '../../../../core/errors/bodyParseWrongChunkReceived.mjs';
+import { BodySizeExceedsLimitError } from '../../../../core/errors/bodySizeExceedsLimitError.mjs';
+
+async function readRequestText(request, params, onEnd) {
+    let result = "";
+    let size = 0;
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                return E.error(new BodyParseWrongChunkReceived("Buffer or String.", chunk));
+            }
+            size += chunk instanceof Buffer
+                ? chunk.byteLength
+                : Buffer.byteLength(chunk);
+            if (size > params.maxBodySize) {
+                return E.error(new BodySizeExceedsLimitError(params.maxBodySize));
+            }
+            result += chunk.toString();
+        }
+        if (onEnd) {
+            return await onEnd(result);
+        }
+        return result;
+    }
+    catch (error) {
+        return E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+export { readRequestText };

package/dist/interfaces/node/createHttpServer.cjs

@@ -1,12 +1,16 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var http = require('http');
 var https = require('https');
-var hooks = require('./hooks.cjs');
+var index$3 = require('./hooks/index.cjs');
 var implementHttpServer = require('../../core/implementHttpServer.cjs');
+var utils = require('@duplojs/utils');
+var index$2 = require('../../core/defaultHooks/index.cjs');
+require('./bodyReaders/index.cjs');
+var index = require('./bodyReaders/text/index.cjs');
+var index$1 = require('./bodyReaders/formData/index.cjs');
 
-function createHttpServer(inputHub, params) {
+function createHttpServer(hub, params) {
     const httpServerParams = utils.O.override({
         host: "localhost",
         port: 80,
@@ -15,9 +19,13 @@ function createHttpServer(inputHub, params) {
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
+        uploadFolder: "./upload",
     }, params);
-    const hooks$1 = hooks.makeNodeHook(inputHub, httpServerParams);
-    const hub = inputHub.addRouteHooks(hooks$1);
+    hub.addBodyReaderImplementation([
+        index.createTextBodyReaderImplementation(httpServerParams),
+        index$1.createFormDataBodyReaderImplementation(httpServerParams),
+    ]);
+    hub.addRouteHooks([index$2.initDefaultHook(hub, httpServerParams), index$3.nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {

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

@@ -1,20 +1,21 @@
-import { type HttpServerParams, type Hub } from "../../core/hub";
-import { type Hosts } from "./types/host";
-import { type BytesInString, O } from "@duplojs/utils";
+import { type Hub } from "../../core/hub";
 import http from "http";
 import https from "https";
-declare module "../../core/hub" {
+import { O } from "@duplojs/utils";
+import { type HttpServerParams } from "../../core/types";
+declare module "../../core/types" {
     interface HttpServerParams {
         readonly interface: "node";
-        readonly host: Hosts;
-        readonly port: number;
-        readonly maxBodySize: BytesInString | number;
-        readonly informationHeaderKey: string;
-        readonly predictedHeaderKey: string;
-        readonly fromHookHeaderKey: string;
         readonly http?: http.ServerOptions;
         readonly https?: https.ServerOptions;
     }
+    interface HostCustom {
+        "::": true;
+        "0.0.0.0": true;
+        localhost: true;
+        "127.0.0.1": true;
+        "::1": true;
+    }
 }
-export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey">;
-export declare function createHttpServer(inputHub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
+export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey" | "uploadFolder">;
+export declare function createHttpServer(hub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -1,10 +1,14 @@
-import { O } from '@duplojs/utils';
 import http from 'http';
 import https from 'https';
-import { makeNodeHook } from './hooks.mjs';
+import { nodeHook } from './hooks/index.mjs';
 import { implementHttpServer } from '../../core/implementHttpServer.mjs';
+import { O } from '@duplojs/utils';
+import { initDefaultHook } from '../../core/defaultHooks/index.mjs';
+import './bodyReaders/index.mjs';
+import { createTextBodyReaderImplementation } from './bodyReaders/text/index.mjs';
+import { createFormDataBodyReaderImplementation } from './bodyReaders/formData/index.mjs';
 
-function createHttpServer(inputHub, params) {
+function createHttpServer(hub, params) {
     const httpServerParams = O.override({
         host: "localhost",
         port: 80,
@@ -13,9 +17,13 @@ function createHttpServer(inputHub, params) {
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
+        uploadFolder: "./upload",
     }, params);
-    const hooks = makeNodeHook(inputHub, httpServerParams);
-    const hub = inputHub.addRouteHooks(hooks);
+    hub.addBodyReaderImplementation([
+        createTextBodyReaderImplementation(httpServerParams),
+        createFormDataBodyReaderImplementation(httpServerParams),
+    ]);
+    hub.addRouteHooks([initDefaultHook(hub, httpServerParams), nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {

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,15 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript__namespace.render(utils.DP.union(dataParserRoutes), {
                         identifier: "Routes",
-                        transformers: DataParserToTypescript__namespace.defaultTransformers,
+                        mode: "in",
+                        transformers: [
+                            typescriptTransfomer.fileTransformer,
+                            typescriptTransfomer.dateTransformer,
+                            typescriptTransfomer.timeTransformer,
+                            ...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, dateTransformer, timeTransformer } 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,15 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript.render(DP.union(dataParserRoutes), {
                         identifier: "Routes",
-                        transformers: DataParserToTypescript.defaultTransformers,
+                        mode: "in",
+                        transformers: [
+                            fileTransformer,
+                            dateTransformer,
+                            timeTransformer,
+                            ...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,28 @@
+'use strict';
+
+var DataParserToTypescript = require('@duplojs/data-parser-tools/toTypescript');
+var serverUtils = require('@duplojs/server-utils');
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+
+const fileTransformer = DataParserToTypescript.createTransformer(serverUtils.SDP.fileKind.has, (__, { success }) => success(typescript.factory.createTypeReferenceNode("File")));
+const dateTransformer = DataParserToTypescript.createTransformer(utils.DP.dateKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    addImport("@duplojs/utils/date", "SerializedTheDate");
+    return success(typescript.factory.createUnionTypeNode([
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheDate")),
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheDate")),
+    ]));
+});
+const timeTransformer = DataParserToTypescript.createTransformer(utils.DP.timeKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    addImport("@duplojs/utils/date", "SerializedTheTime");
+    return success(typescript.factory.createUnionTypeNode([
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheTime")),
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheTime")),
+    ]));
+});
+
+exports.dateTransformer = dateTransformer;
+exports.fileTransformer = fileTransformer;
+exports.timeTransformer = timeTransformer;

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

@@ -0,0 +1,4 @@
+import { DP } from "@duplojs/utils";
+export declare const fileTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;
+export declare const dateTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;
+export declare const timeTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;