@duplojs/http 0.2.0 → 0.5.0

package/dist/interfaces/node/hooks.mjs

@@ -1,14 +1,16 @@
 import '../../core/route/index.mjs';
 import { stringToBytes } from '@duplojs/utils';
 import './error/index.mjs';
-import { createHookRouteLifeCycle } from '../../core/route/hooks/index.mjs';
-import { HookResponse } from '../../core/route/hooks/response.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
+import { PredictedResponse } from '../../core/response/predicted.mjs';
+import { HookResponse } from '../../core/response/hook.mjs';
 import { BodySizeExceedsLimitError } from './error/bodySizeExceedsLimitError.mjs';
 import { BodyParseWrongChunkReceived } from './error/bodyParseWrongChunkReceived.mjs';
 import { BodyParseUnknownError } from './error/bodyParseUnknownError.mjs';
 
 function makeNodeHook(hub, serverParams) {
     const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
     const fromHookHeaderKey = serverParams.fromHookHeaderKey;
     const isDev = hub.config.environment === "DEV";
     const maxBodySize = stringToBytes(serverParams.maxBodySize);
@@ -77,17 +79,20 @@ function makeNodeHook(hub, serverParams) {
         },
         beforeSendResponse({ request, currentResponse, exit }) {
             const body = currentResponse.body;
-            if (typeof body === "number"
-                || typeof body === "string"
-                || body === null
+            if (typeof body === "string"
                 || body instanceof Error) {
                 currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 currentResponse.setHeader("content-type", "application/json; charset=utf-8");
             }
             currentResponse.setHeader(informationHeaderKey, currentResponse.information);
-            if (currentResponse instanceof HookResponse) {
+            if (currentResponse instanceof PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof HookResponse) {
                 currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
             }
             request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
@@ -99,16 +104,14 @@ function makeNodeHook(hub, serverParams) {
             if (body instanceof Error) {
                 rawResponse.write(body.toString());
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 rawResponse.write(JSON.stringify(body));
             }
             else if (typeof body === "string") {
                 rawResponse.write(body);
             }
-            else if (typeof body === "number"
-                || typeof body === "bigint") {
-                rawResponse.write(body.toString());
-            }
             rawResponse.end();
             return exit();
         },

package/dist/plugins/codeGenerator/{stepsToDataParser.cjs → aggregateStepContract.cjs}

@@ -2,6 +2,8 @@
 
 require('../../core/steps/index.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
+var identifier = require('../../core/steps/identifier.cjs');
 var process = require('../../core/steps/process.cjs');
 var extract = require('../../core/steps/extract.cjs');
 var presetChecker = require('../../core/steps/presetChecker.cjs');
@@ -9,12 +11,13 @@ var checker = require('../../core/steps/checker.cjs');
 var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
 
-function stepsToDataParser(steps, params) {
-    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), utils.O.to({
+function aggregateStepContract(steps, params) {
+    const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined);
+    const processContracts = utils.pipe(filteredStep, utils.A.filter(identifier.stepIdentifier(process.processStepKind)), utils.A.filter((step) => utils.A.find(step.definition.process.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
         entrypointContract: utils.A.map((result) => result.entrypointContract),
         endpointContract: utils.A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+    const entrypointContract = utils.pipe(filteredStep, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -43,7 +46,7 @@ function stepsToDataParser(steps, params) {
         }
         return utils.O.entry(key, currentExtractDataParser);
     }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+    const endpointContract = utils.pipe(filteredStep, utils.A.flatMap((step) => utils.P.match(step)
         .when(process.processStepKind.has, () => [])
         .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
@@ -63,4 +66,4 @@ function stepsToDataParser(steps, params) {
     };
 }
 
-exports.stepsToDataParser = stepsToDataParser;
+exports.aggregateStepContract = aggregateStepContract;

package/dist/plugins/codeGenerator/{stepsToDataParser.d.ts → aggregateStepContract.d.ts}

@@ -10,5 +10,5 @@ export interface StepsToDataParserResult {
     entrypointContract: EntrypointReduceResult;
     endpointContract: DP.DataParser[];
 }
-export declare function stepsToDataParser(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
+export declare function aggregateStepContract(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
 export {};

package/dist/plugins/codeGenerator/{stepsToDataParser.mjs → aggregateStepContract.mjs}

@@ -1,5 +1,7 @@
 import '../../core/steps/index.mjs';
-import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { A, pipe, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
+import { stepIdentifier } from '../../core/steps/identifier.mjs';
 import { processStepKind } from '../../core/steps/process.mjs';
 import { extractStepKind } from '../../core/steps/extract.mjs';
 import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
@@ -7,12 +9,13 @@ import { checkerStepKind } from '../../core/steps/checker.mjs';
 import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
 
-function stepsToDataParser(steps, params) {
-    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), O.to({
+function aggregateStepContract(steps, params) {
+    const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined);
+    const processContracts = pipe(filteredStep, A.filter(stepIdentifier(processStepKind)), A.filter((step) => A.find(step.definition.process.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
         entrypointContract: A.map((result) => result.entrypointContract),
         endpointContract: A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+    const entrypointContract = pipe(filteredStep, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -41,7 +44,7 @@ function stepsToDataParser(steps, params) {
         }
         return O.entry(key, currentExtractDataParser);
     }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+    const endpointContract = pipe(filteredStep, A.flatMap((step) => P.match(step)
         .when(processStepKind.has, () => [])
         .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
@@ -61,4 +64,4 @@ function stepsToDataParser(steps, params) {
     };
 }
 
-export { stepsToDataParser };
+export { aggregateStepContract };

package/dist/plugins/codeGenerator/index.cjs

@@ -4,13 +4,12 @@ require('@duplojs/data-parser-tools/toTypescript');
 require('./types/index.cjs');
 var plugin = require('./plugin.cjs');
 var routeToDataParser = require('./routeToDataParser.cjs');
-var stepsToDataParser = require('./stepsToDataParser.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
+var metadata = require('./metadata.cjs');
 
 
 
 exports.codeGeneratorPlugin = plugin.codeGeneratorPlugin;
-exports.digitDataParser = routeToDataParser.digitDataParser;
-exports.responseCodeDataParser = routeToDataParser.responseCodeDataParser;
-exports.responseCodeDataParsers = routeToDataParser.responseCodeDataParsers;
 exports.routeToDataParser = routeToDataParser.routeToDataParser;
-exports.stepsToDataParser = stepsToDataParser.stepsToDataParser;
+exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
+exports.IgnoreByCodeGeneratorMetadata = metadata.IgnoreByCodeGeneratorMetadata;

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

@@ -2,4 +2,5 @@ import "@duplojs/data-parser-tools/toTypescript";
 export * from "./types";
 export * from "./plugin";
 export * from "./routeToDataParser";
-export * from "./stepsToDataParser";
+export * from "./aggregateStepContract";
+export * from "./metadata";

package/dist/plugins/codeGenerator/index.mjs

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

package/dist/plugins/codeGenerator/metadata.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../../core/metadata/index.cjs');
+var base = require('../../core/metadata/base.cjs');
+
+const IgnoreByCodeGeneratorMetadata = base.createMetadata("ignore-by-code-generator");
+
+exports.IgnoreByCodeGeneratorMetadata = IgnoreByCodeGeneratorMetadata;

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

@@ -0,0 +1 @@
+export declare const IgnoreByCodeGeneratorMetadata: import("../../core/metadata").MetadataHandler<"ignore-by-code-generator", unknown>;

package/dist/plugins/codeGenerator/metadata.mjs

@@ -0,0 +1,6 @@
+import '../../core/metadata/index.mjs';
+import { createMetadata } from '../../core/metadata/base.mjs';
+
+const IgnoreByCodeGeneratorMetadata = createMetadata("ignore-by-code-generator");
+
+export { IgnoreByCodeGeneratorMetadata };

package/dist/plugins/codeGenerator/plugin.cjs

@@ -31,7 +31,7 @@ function codeGeneratorPlugin(pluginParams) {
             {
                 beforeStartServer: async (hub) => {
                     const routes = hub.aggregatesRoutes();
-                    const dataParserRoutes = utils.A.map(routes, (route) => routeToDataParser.routeToDataParser(route, {
+                    const dataParserRoutes = utils.A.flatMap(routes, (route) => routeToDataParser.routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
                     if (!utils.A.minElements(dataParserRoutes, 1)) {

package/dist/plugins/codeGenerator/plugin.mjs

@@ -10,7 +10,7 @@ function codeGeneratorPlugin(pluginParams) {
             {
                 beforeStartServer: async (hub) => {
                     const routes = hub.aggregatesRoutes();
-                    const dataParserRoutes = A.map(routes, (route) => routeToDataParser(route, {
+                    const dataParserRoutes = A.flatMap(routes, (route) => routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
                     if (!A.minElements(dataParserRoutes, 1)) {

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -1,48 +1,18 @@
 'use strict';
 
-var stepsToDataParser = require('./stepsToDataParser.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
 
-const digitDataParser = utils.DP.literal(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]).setIdentifier("Digit");
-const responseCodeDataParsers = {
-    information: utils.DP.templateLiteral([
-        "1",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    success: utils.DP.templateLiteral([
-        "2",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    redirection: utils.DP.templateLiteral([
-        "3",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    clientError: utils.DP.templateLiteral([
-        "4",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    serverError: utils.DP.templateLiteral([
-        "5",
-        digitDataParser,
-        digitDataParser,
-    ]),
-};
-const responseCodeDataParser = utils.DP.union([
-    responseCodeDataParsers.information,
-    responseCodeDataParsers.success,
-    responseCodeDataParsers.redirection,
-    responseCodeDataParsers.clientError,
-    responseCodeDataParsers.serverError,
-]).setIdentifier("ResponseCode");
 function routeToDataParser(route, params) {
+    const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     return utils.pipe([
         ...route.definition.preflightSteps,
         ...route.definition.steps,
-    ], (steps) => stepsToDataParser.stepsToDataParser(steps, {
+    ], (steps) => aggregateStepContract.aggregateStepContract(steps, {
         defaultExtractContract: params.defaultExtractContract,
     }), utils.O.transformProperty("entrypointContract", utils.innerPipe(utils.O.entries, utils.A.select(({ element: [key, value], select, skip }) => {
         if (utils.DP.dataParserKind.has(value)) {
@@ -52,28 +22,12 @@ function routeToDataParser(route, params) {
             return select(utils.O.entry(key, utils.DP.object(value)));
         }
         return skip();
-    }), utils.O.fromEntries)), ({ endpointContract, entrypointContract }) => utils.DP.object({
+    }), 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(route.definition.paths),
+        path: utils.DP.literal(path),
         ...entrypointContract,
-        responses: utils.DP.union([
-            utils.DP.object({
-                code: responseCodeDataParser,
-                information: utils.DP.string(),
-                body: utils.DP.unknown(),
-                fromHook: utils.DP.literal(true),
-            }),
-            utils.DP.object({
-                code: responseCodeDataParsers.serverError,
-                information: utils.DP.string(),
-                body: utils.DP.unknown(),
-            }),
-            ...endpointContract,
-        ]),
-    }));
+        responses: utils.DP.union(endpointContract),
+    })));
 }
 
-exports.digitDataParser = digitDataParser;
-exports.responseCodeDataParser = responseCodeDataParser;
-exports.responseCodeDataParsers = responseCodeDataParsers;
 exports.routeToDataParser = routeToDataParser;

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

@@ -1,186 +1,7 @@
 import { type Route } from "../../core/route";
-import { DP, type DString } from "@duplojs/utils";
+import { DP } from "@duplojs/utils";
 import { type ResponseContract } from "../../core/response";
 export interface RouteToDataParserParams {
     readonly defaultExtractContract: ResponseContract.Contract;
 }
-export declare const digitDataParser: DP.DataParserLiteral<{
-    readonly value: readonly DString.Digit[];
-    readonly errorMessage?: string | undefined;
-    readonly identifier?: string | undefined;
-    readonly checkers: readonly [];
-}>;
-export declare const responseCodeDataParsers: {
-    information: DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["1", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>;
-    success: DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["2", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>;
-    redirection: DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["3", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>;
-    clientError: DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["4", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>;
-    serverError: DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["5", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>;
-};
-export declare const responseCodeDataParser: DP.DataParserUnion<{
-    readonly options: [DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["1", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>, DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["2", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>, DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["3", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>, DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["4", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>, DP.DataParserTemplateLiteral<{
-        readonly template: readonly ["5", DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>, DP.DataParserLiteral<{
-            readonly value: readonly DString.Digit[];
-            readonly errorMessage?: string | undefined;
-            readonly identifier?: string | undefined;
-            readonly checkers: readonly [];
-        }>];
-        readonly errorMessage?: string | undefined;
-        readonly identifier?: string | undefined;
-        readonly pattern: RegExp;
-        readonly checkers: readonly [];
-    }>];
-    readonly errorMessage?: string | undefined;
-    readonly identifier?: string | undefined;
-    readonly checkers: readonly [];
-}>;
-export declare function routeToDataParser(route: Route, params: RouteToDataParserParams): DP.DataParser;
+export declare function routeToDataParser(route: Route, params: RouteToDataParserParams): DP.DataParser[];

package/dist/plugins/codeGenerator/routeToDataParser.mjs

@@ -1,46 +1,16 @@
-import { stepsToDataParser } from './stepsToDataParser.mjs';
-import { DP, pipe, O, innerPipe, A } from '@duplojs/utils';
+import { aggregateStepContract } from './aggregateStepContract.mjs';
+import { A, pipe, O, innerPipe, DP } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
 
-const digitDataParser = DP.literal(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]).setIdentifier("Digit");
-const responseCodeDataParsers = {
-    information: DP.templateLiteral([
-        "1",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    success: DP.templateLiteral([
-        "2",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    redirection: DP.templateLiteral([
-        "3",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    clientError: DP.templateLiteral([
-        "4",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    serverError: DP.templateLiteral([
-        "5",
-        digitDataParser,
-        digitDataParser,
-    ]),
-};
-const responseCodeDataParser = DP.union([
-    responseCodeDataParsers.information,
-    responseCodeDataParsers.success,
-    responseCodeDataParsers.redirection,
-    responseCodeDataParsers.clientError,
-    responseCodeDataParsers.serverError,
-]).setIdentifier("ResponseCode");
 function routeToDataParser(route, params) {
+    const isIgnore = A.find(route.definition.metadata, IgnoreByCodeGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     return pipe([
         ...route.definition.preflightSteps,
         ...route.definition.steps,
-    ], (steps) => stepsToDataParser(steps, {
+    ], (steps) => aggregateStepContract(steps, {
         defaultExtractContract: params.defaultExtractContract,
     }), O.transformProperty("entrypointContract", innerPipe(O.entries, A.select(({ element: [key, value], select, skip }) => {
         if (DP.dataParserKind.has(value)) {
@@ -50,25 +20,12 @@ function routeToDataParser(route, params) {
             return select(O.entry(key, DP.object(value)));
         }
         return skip();
-    }), O.fromEntries)), ({ endpointContract, entrypointContract }) => DP.object({
+    }), O.fromEntries)), ({ endpointContract, entrypointContract }) => A.map(route.definition.paths, (path) => DP.object({
         method: DP.literal(route.definition.method),
-        path: DP.literal(route.definition.paths),
+        path: DP.literal(path),
         ...entrypointContract,
-        responses: DP.union([
-            DP.object({
-                code: responseCodeDataParser,
-                information: DP.string(),
-                body: DP.unknown(),
-                fromHook: DP.literal(true),
-            }),
-            DP.object({
-                code: responseCodeDataParsers.serverError,
-                information: DP.string(),
-                body: DP.unknown(),
-            }),
-            ...endpointContract,
-        ]),
-    }));
+        responses: DP.union(endpointContract),
+    })));
 }
 
-export { digitDataParser, responseCodeDataParser, responseCodeDataParsers, routeToDataParser };
+export { routeToDataParser };