@duplojs/http 0.4.0 → 0.5.1

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,10 +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.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

@@ -2,4 +2,5 @@ import '@duplojs/data-parser-tools/toTypescript';
 import './types/index.mjs';
 export { codeGeneratorPlugin } from './plugin.mjs';
 export { routeToDataParser } from './routeToDataParser.mjs';
-export { stepsToDataParser } from './stepsToDataParser.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

@@ -30,6 +30,9 @@ function codeGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeStartServer: async (hub) => {
+                    if (!utils.equal(hub.config.environment, ["DEV", "BUILD"])) {
+                        return;
+                    }
                     const routes = hub.aggregatesRoutes();
                     const dataParserRoutes = utils.A.flatMap(routes, (route) => routeToDataParser.routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,

package/dist/plugins/codeGenerator/plugin.mjs

@@ -1,5 +1,5 @@
 import * as DataParserToTypescript from '@duplojs/data-parser-tools/toTypescript';
-import { A, DP } from '@duplojs/utils';
+import { equal, A, DP } from '@duplojs/utils';
 import { routeToDataParser } from './routeToDataParser.mjs';
 import { writeFile } from 'node:fs/promises';
 
@@ -9,6 +9,9 @@ function codeGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeStartServer: async (hub) => {
+                    if (!equal(hub.config.environment, ["DEV", "BUILD"])) {
+                        return;
+                    }
                     const routes = hub.aggregatesRoutes();
                     const dataParserRoutes = A.flatMap(routes, (route) => routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -1,13 +1,18 @@
 'use strict';
 
-var stepsToDataParser = require('./stepsToDataParser.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
 
 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)) {

package/dist/plugins/codeGenerator/routeToDataParser.mjs

@@ -1,11 +1,16 @@
-import { stepsToDataParser } from './stepsToDataParser.mjs';
-import { pipe, O, innerPipe, A, DP } from '@duplojs/utils';
+import { aggregateStepContract } from './aggregateStepContract.mjs';
+import { A, pipe, O, innerPipe, DP } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
 
 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)) {

package/dist/plugins/openApiGenerator/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');
@@ -10,11 +12,12 @@ var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
 
 function aggregateStepContract(steps, params) {
-    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
+    const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.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.IgnoreByOpenApiGeneratorMetadata.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 aggregateStepContract(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)

package/dist/plugins/openApiGenerator/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 { IgnoreByOpenApiGeneratorMetadata } 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';
@@ -8,11 +10,12 @@ import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
 
 function aggregateStepContract(steps, params) {
-    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
+    const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is) === undefined);
+    const processContracts = pipe(filteredStep, A.filter(stepIdentifier(processStepKind)), A.filter((step) => A.find(step.definition.process.definition.metadata, IgnoreByOpenApiGeneratorMetadata.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 aggregateStepContract(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)

package/dist/plugins/openApiGenerator/index.cjs

@@ -7,6 +7,7 @@ var routeToOpenApi = require('./routeToOpenApi.cjs');
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var makeOpenApiRoute = require('./makeOpenApiRoute.cjs');
 var makeOpenApiPage = require('./makeOpenApiPage.cjs');
+var metadata = require('./metadata.cjs');
 
 
 
@@ -15,3 +16,4 @@ exports.routeToOpenApi = routeToOpenApi.routeToOpenApi;
 exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
 exports.makeOpenApiRoute = makeOpenApiRoute.makeOpenApiRoute;
 exports.makeOpenApiPage = makeOpenApiPage.makeOpenApiPage;
+exports.IgnoreByOpenApiGeneratorMetadata = metadata.IgnoreByOpenApiGeneratorMetadata;

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

@@ -5,3 +5,4 @@ export * from "./routeToOpenApi";
 export * from "./aggregateStepContract";
 export * from "./makeOpenApiRoute";
 export * from "./makeOpenApiPage";
+export * from "./metadata";

package/dist/plugins/openApiGenerator/index.mjs

@@ -5,3 +5,4 @@ export { routeToOpenApi } from './routeToOpenApi.mjs';
 export { aggregateStepContract } from './aggregateStepContract.mjs';
 export { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
 export { makeOpenApiPage } from './makeOpenApiPage.mjs';
+export { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';

package/dist/plugins/openApiGenerator/makeOpenApiRoute.cjs

@@ -1,13 +1,15 @@
 'use strict';
 
 require('../../core/builders/index.cjs');
+require('../../core/metadata/index.cjs');
 require('../../core/response/index.cjs');
 var utils = require('@duplojs/utils');
 var builder = require('../../core/builders/route/builder.cjs');
+var ignoreByRouteStore = require('../../core/metadata/ignoreByRouteStore.cjs');
 var contract = require('../../core/response/contract.cjs');
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return builder.useRouteBuilder("GET", routePath)
+    return builder.useRouteBuilder("GET", routePath, { metadata: [ignoreByRouteStore.IgnoreByRouteStoreMetadata()] })
         .handler(contract.ResponseContract.ok("swaggerUi", utils.DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

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

@@ -3,6 +3,7 @@ import type { RoutePath } from "../../core/route";
 import { DP } from "@duplojs/utils";
 export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
     readonly method: "GET";
+    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];
@@ -14,5 +15,6 @@ export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: stri
             readonly checkers: readonly [];
         }>>>;
         theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>;
+        readonly metadata: readonly [];
     }>];
 }>;

package/dist/plugins/openApiGenerator/makeOpenApiRoute.mjs

@@ -1,11 +1,13 @@
 import '../../core/builders/index.mjs';
+import '../../core/metadata/index.mjs';
 import '../../core/response/index.mjs';
 import { DP } from '@duplojs/utils';
 import { useRouteBuilder } from '../../core/builders/route/builder.mjs';
+import { IgnoreByRouteStoreMetadata } from '../../core/metadata/ignoreByRouteStore.mjs';
 import { ResponseContract } from '../../core/response/contract.mjs';
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return useRouteBuilder("GET", routePath)
+    return useRouteBuilder("GET", routePath, { metadata: [IgnoreByRouteStoreMetadata()] })
         .handler(ResponseContract.ok("swaggerUi", DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

package/dist/plugins/openApiGenerator/metadata.cjs

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

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

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

package/dist/plugins/openApiGenerator/metadata.mjs

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

package/dist/plugins/openApiGenerator/plugin.cjs

@@ -12,6 +12,11 @@ function openApiGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeServerBuildRoutes: async (hub) => {
+                    if (!utils.equal(hub.config.environment, ["DEV", "BUILD"])
+                        || (!pluginParams.routePath
+                            && !pluginParams.outputFile)) {
+                        return;
+                    }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
                     const routes = hub.aggregatesRoutes();
@@ -71,16 +76,19 @@ function openApiGeneratorPlugin(pluginParams) {
                             : undefined,
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
-                    if (pluginParams.outputFilePath) {
-                        await promises.writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    if (pluginParams.outputFile) {
+                        await promises.writeFile(pluginParams.outputFile, openApiDocumentString);
+                    }
+                    if (pluginParams.routePath) {
+                        const openApiPage = makeOpenApiPage.makeOpenApiPage({
+                            openApiDocument: openApiDocumentString,
+                            pageTitle: pluginParams.title ?? "Swagger API",
+                            swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                        });
+                        const openApiRoute = makeOpenApiRoute.makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                        return hub.register(openApiRoute);
                     }
-                    const openApiPage = makeOpenApiPage.makeOpenApiPage({
-                        openApiDocument: openApiDocumentString,
-                        pageTitle: pluginParams.title ?? "Swagger API",
-                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
-                    });
-                    const openApiRoute = makeOpenApiRoute.makeOpenApiRoute(pluginParams.routePath, openApiPage);
-                    return hub.register(openApiRoute);
+                    return;
                 },
             },
         ],

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

@@ -14,8 +14,8 @@ interface OpenApiSecurityOptionBasic {
     type: "basic";
 }
 export interface OpenApiGeneratorPluginParams {
-    routePath: RoutePath;
-    outputFilePath?: string;
+    routePath?: RoutePath;
+    outputFile?: string;
     /**
      * @default "Swagger API"
      */

package/dist/plugins/openApiGenerator/plugin.mjs

@@ -1,5 +1,5 @@
 import { routeToOpenApi } from './routeToOpenApi.mjs';
-import { pipe, A, O, G, P, justReturn } from '@duplojs/utils';
+import { equal, pipe, A, O, G, P, justReturn } from '@duplojs/utils';
 import { makeOpenApiPage } from './makeOpenApiPage.mjs';
 import { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
 import { writeFile } from 'fs/promises';
@@ -10,6 +10,11 @@ function openApiGeneratorPlugin(pluginParams) {
         hooksHubLifeCycle: [
             {
                 beforeServerBuildRoutes: async (hub) => {
+                    if (!equal(hub.config.environment, ["DEV", "BUILD"])
+                        || (!pluginParams.routePath
+                            && !pluginParams.outputFile)) {
+                        return;
+                    }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
                     const routes = hub.aggregatesRoutes();
@@ -69,16 +74,19 @@ function openApiGeneratorPlugin(pluginParams) {
                             : undefined,
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
-                    if (pluginParams.outputFilePath) {
-                        await writeFile(pluginParams.outputFilePath, openApiDocumentString);
+                    if (pluginParams.outputFile) {
+                        await writeFile(pluginParams.outputFile, openApiDocumentString);
+                    }
+                    if (pluginParams.routePath) {
+                        const openApiPage = makeOpenApiPage({
+                            openApiDocument: openApiDocumentString,
+                            pageTitle: pluginParams.title ?? "Swagger API",
+                            swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
+                        });
+                        const openApiRoute = makeOpenApiRoute(pluginParams.routePath, openApiPage);
+                        return hub.register(openApiRoute);
                     }
-                    const openApiPage = makeOpenApiPage({
-                        openApiDocument: openApiDocumentString,
-                        pageTitle: pluginParams.title ?? "Swagger API",
-                        swaggerUiVersion: pluginParams.swaggerUiVersion ?? "5.31.0",
-                    });
-                    const openApiRoute = makeOpenApiRoute(pluginParams.routePath, openApiPage);
-                    return hub.register(openApiRoute);
+                    return;
                 },
             },
         ],

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -3,6 +3,7 @@
 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
@@ -33,6 +34,10 @@ const methodMapper = {
     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,

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -1,6 +1,7 @@
 import { aggregateStepContract } from './aggregateStepContract.mjs';
-import { O, pipe, A, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
+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
@@ -31,6 +32,10 @@ const methodMapper = {
     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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",