@duplojs/http 0.7.4 → 0.8.5

package/dist/plugins/cacheController/types/cacheControlDirectives.cjs

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

package/dist/plugins/cacheController/types/cacheControlDirectives.d.ts

@@ -0,0 +1,16 @@
+export interface CacheControlDirectives {
+    maxAge?: number;
+    sMaxAge?: number;
+    public?: true;
+    private?: true | string[];
+    noCache?: true | string[];
+    noStore?: true;
+    noTransform?: true;
+    mustRevalidate?: true;
+    proxyRevalidate?: true;
+    immutable?: true;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    mustUnderstand?: true;
+    extensions?: Record<string, string>;
+}

package/dist/plugins/cacheController/types/cacheControlDirectives.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/cacheController/types/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./cacheControlDirectives.cjs');
+

package/dist/plugins/cacheController/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./cacheControlDirectives";

package/dist/plugins/cacheController/types/index.mjs

@@ -0,0 +1 @@
+import './cacheControlDirectives.mjs';

package/dist/plugins/codeGenerator/aggregateStepContract.cjs

@@ -2,6 +2,7 @@
 
 require('../../core/steps/index.cjs');
 var utils = require('@duplojs/utils');
+require('../../core/response/index.cjs');
 var metadata = require('./metadata.cjs');
 var identifier = require('../../core/steps/identifier.cjs');
 var process = require('../../core/steps/process.cjs');
@@ -10,6 +11,7 @@ var presetChecker = require('../../core/steps/presetChecker.cjs');
 var checker = require('../../core/steps/checker.cjs');
 var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
+var contract = require('../../core/response/contract.cjs');
 
 function aggregateStepContract(steps, params) {
     const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined);
@@ -55,11 +57,16 @@ function aggregateStepContract(steps, params) {
         cut.cutStepKind,
         handler.handlerStepKind,
     ]), ({ definition }) => definition.responseContract)
-        .exhaustive()), utils.A.map(({ code, information, body }) => utils.DP.object({
+        .exhaustive()), utils.A.map(utils.innerPipe(utils.P.when(contract.ResponseContract.contractKind.has, ({ code, information, body }) => utils.DP.object({
         code: utils.DP.literal(code),
         information: utils.DP.literal(information),
         body,
-    })), utils.A.concat(processContracts.endpointContract));
+    })), utils.P.when(contract.ResponseContract.serverSentEventsContractKind.has, ({ code, information, body, events }) => utils.DP.object({
+        code: utils.DP.literal(code),
+        information: utils.DP.literal(information),
+        body,
+        events: utils.DP.object(events),
+    })), utils.P.exhaustive)), utils.A.concat(processContracts.endpointContract));
     return {
         entrypointContract,
         endpointContract,

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

@@ -1,7 +1,7 @@
 import { type Steps } from "../../core/steps";
 import { DP } from "@duplojs/utils";
 import { type EntrypointKey } from "./types";
-import { type ResponseContract } from "../../core/response";
+import { ResponseContract } from "../../core/response";
 type EntrypointReduceResult = Record<EntrypointKey, DP.DataParser | Record<string, DP.DataParser>>;
 export interface StepsToDataParserParams {
     readonly defaultExtractContract: ResponseContract.Contract;

package/dist/plugins/codeGenerator/aggregateStepContract.mjs

@@ -1,5 +1,6 @@
 import '../../core/steps/index.mjs';
-import { A, pipe, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { A, pipe, O, DP, P, hasSomeKinds, innerPipe } from '@duplojs/utils';
+import '../../core/response/index.mjs';
 import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
 import { stepIdentifier } from '../../core/steps/identifier.mjs';
 import { processStepKind } from '../../core/steps/process.mjs';
@@ -8,6 +9,7 @@ import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
 import { checkerStepKind } from '../../core/steps/checker.mjs';
 import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
+import { ResponseContract } from '../../core/response/contract.mjs';
 
 function aggregateStepContract(steps, params) {
     const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined);
@@ -53,11 +55,16 @@ function aggregateStepContract(steps, params) {
         cutStepKind,
         handlerStepKind,
     ]), ({ definition }) => definition.responseContract)
-        .exhaustive()), A.map(({ code, information, body }) => DP.object({
+        .exhaustive()), A.map(innerPipe(P.when(ResponseContract.contractKind.has, ({ code, information, body }) => DP.object({
         code: DP.literal(code),
         information: DP.literal(information),
         body,
-    })), A.concat(processContracts.endpointContract));
+    })), P.when(ResponseContract.serverSentEventsContractKind.has, ({ code, information, body, events }) => DP.object({
+        code: DP.literal(code),
+        information: DP.literal(information),
+        body,
+        events: DP.object(events),
+    })), P.exhaustive)), A.concat(processContracts.endpointContract));
     return {
         entrypointContract,
         endpointContract,

package/dist/plugins/codeGenerator/plugin.cjs

@@ -4,7 +4,7 @@ var DataParserToTypescript = require('@duplojs/data-parser-tools/toTypescript');
 var utils = require('@duplojs/utils');
 var routeToDataParser = require('./routeToDataParser.cjs');
 var serverUtils = require('@duplojs/server-utils');
-var typescriptTransfomer = require('./typescriptTransfomer.cjs');
+var typescriptTransformer = require('./typescriptTransformer.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -45,9 +45,9 @@ function codeGeneratorPlugin(pluginParams) {
                         identifier: "Routes",
                         mode: "in",
                         transformers: [
-                            typescriptTransfomer.fileTransformer,
-                            typescriptTransfomer.dateTransformer,
-                            typescriptTransfomer.timeTransformer,
+                            typescriptTransformer.fileTransformer,
+                            typescriptTransformer.dateTransformer,
+                            typescriptTransformer.timeTransformer,
                             ...DataParserToTypescript__namespace.defaultTransformers,
                         ],
                     });

package/dist/plugins/codeGenerator/plugin.mjs

@@ -2,7 +2,7 @@ import * as DataParserToTypescript from '@duplojs/data-parser-tools/toTypescript
 import { equal, A, DP, asserts, E } from '@duplojs/utils';
 import { routeToDataParser } from './routeToDataParser.mjs';
 import { SF } from '@duplojs/server-utils';
-import { fileTransformer, dateTransformer, timeTransformer } from './typescriptTransfomer.mjs';
+import { fileTransformer, dateTransformer, timeTransformer } from './typescriptTransformer.mjs';
 
 function codeGeneratorPlugin(pluginParams) {
     return () => ({

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

@@ -1,16 +1,11 @@
 import { type Steps } from "../../core/steps";
 import { DP } from "@duplojs/utils";
-import type { ResponseCode, ResponseContract } from "../../core/response";
+import type { ResponseContract } from "../../core/response";
 import type { EntrypointKey } from "./types";
-export interface EndpointRouteResult {
-    code: ResponseCode;
-    information: string;
-    body: DP.DataParser;
-}
 export type EntrypointReduceResult = Record<EntrypointKey, DP.DataParser | Record<string, DP.DataParser>>;
 export interface AggregateStepsResult {
     entrypointContract: EntrypointReduceResult;
-    endpointContract: EndpointRouteResult[];
+    endpointContract: (ResponseContract.Contract | ResponseContract.ServerSentEventsContract)[];
 }
 export interface AggregateStepsParams {
     readonly defaultExtractContract: ResponseContract.Contract;

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -2,10 +2,12 @@
 
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
+require('../../core/response/index.cjs');
 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');
+var contract = require('../../core/response/contract.cjs');
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -94,14 +96,8 @@ function routeToOpenApi(route, params) {
             },
         },
     })));
-    const responses = utils.pipe(aggregateStepResult.endpointContract, utils.A.reduce(utils.A.reduceFrom({}), ({ lastValue, element: { information, body, code }, nextWithObject }) => {
-        const schemaResponse = !utils.DP.identifier(body, utils.DP.emptyKind)
-            ? factoryJsonSchema({
-                context: params.contextToJsonSchemaFactory,
-                resultSchemaContext: params.resultSchemaContext,
-                schema: body,
-            })
-            : undefined;
+    const responses = utils.pipe(aggregateStepResult.endpointContract, utils.A.reduce(utils.A.reduceFrom({}), ({ lastValue, element: contract$1, nextWithObject, next }) => {
+        const { information, body, code } = contract$1;
         const headerInformation = {
             const: information,
             type: "string",
@@ -128,6 +124,48 @@ function routeToOpenApi(route, params) {
                 description: headerDescription,
             },
         };
+        if (contract.ResponseContract.serverSentEventsContractKind.has(contract$1)) {
+            const eventNameList = utils.O.keys(contract$1.events);
+            const eventDataList = utils.O.values(contract$1.events);
+            if (!utils.A.minElements(eventNameList, 1) || !utils.A.minElements(eventDataList, 1)) {
+                return next(lastValue);
+            }
+            const schema = factoryJsonSchema({
+                context: params.contextToJsonSchemaFactory,
+                resultSchemaContext: params.resultSchemaContext,
+                schema: utils.DP.object({
+                    event: utils.DP.literal(eventNameList),
+                    data: utils.DP.union(eventDataList),
+                    id: utils.DP.optional(utils.DP.string()),
+                    retry: utils.DP.optional(utils.DP.number()),
+                }),
+            });
+            const lastContent = lastValue[code]?.content;
+            const content = {
+                ...lastContent,
+                "text/event-stream": {
+                    itemSchema: lastContent?.["text/event-stream"]
+                        ? {
+                            anyOf: [
+                                lastContent["text/event-stream"].itemSchema,
+                                schema,
+                            ],
+                        }
+                        : schema,
+                },
+            };
+            return nextWithObject(lastValue, {
+                [code]: {
+                    headers,
+                    content,
+                },
+            });
+        }
+        const schemaResponse = factoryJsonSchema({
+            context: params.contextToJsonSchemaFactory,
+            resultSchemaContext: params.resultSchemaContext,
+            schema: body,
+        });
         const content = utils.pipe(body, utils.P.when(utils.DP.identifier(utils.DP.emptyKind), utils.justReturn(lastValue[code]?.content)), utils.P.otherwise((value) => {
             if (utils.DP.identifier(value, utils.DP.stringKind) && lastValue[code]?.content?.["plain/text"]) {
                 return lastValue[code].content;

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

@@ -1,5 +1,5 @@
 import type { Route } from "../../core/route";
-import type { ResponseCode, ResponseContract } from "../../core/response";
+import { ResponseContract } from "../../core/response";
 import { type MapContext, type JsonSchema } from "@duplojs/data-parser-tools/toJsonSchema";
 import type { EndpointResponse, EntrypointParameter } from "./types";
 export type ResultSchemaContext = Map<string, Record<string, JsonSchema>>;
@@ -40,5 +40,5 @@ export declare function routeToOpenApi(route: Route, params: RouteToOpenApiParam
             };
         };
     } | undefined;
-    responses: Partial<Record<ResponseCode, EndpointResponse>>;
+    responses: Partial<Record<string, EndpointResponse>>;
 }[];

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -1,9 +1,11 @@
 import { aggregateStepContract } from './aggregateStepContract.mjs';
 import { O, A, pipe, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
+import '../../core/response/index.mjs';
 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';
+import { ResponseContract } from '../../core/response/contract.mjs';
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -92,14 +94,8 @@ function routeToOpenApi(route, params) {
             },
         },
     })));
-    const responses = pipe(aggregateStepResult.endpointContract, A.reduce(A.reduceFrom({}), ({ lastValue, element: { information, body, code }, nextWithObject }) => {
-        const schemaResponse = !DP.identifier(body, DP.emptyKind)
-            ? factoryJsonSchema({
-                context: params.contextToJsonSchemaFactory,
-                resultSchemaContext: params.resultSchemaContext,
-                schema: body,
-            })
-            : undefined;
+    const responses = pipe(aggregateStepResult.endpointContract, A.reduce(A.reduceFrom({}), ({ lastValue, element: contract, nextWithObject, next }) => {
+        const { information, body, code } = contract;
         const headerInformation = {
             const: information,
             type: "string",
@@ -126,6 +122,48 @@ function routeToOpenApi(route, params) {
                 description: headerDescription,
             },
         };
+        if (ResponseContract.serverSentEventsContractKind.has(contract)) {
+            const eventNameList = O.keys(contract.events);
+            const eventDataList = O.values(contract.events);
+            if (!A.minElements(eventNameList, 1) || !A.minElements(eventDataList, 1)) {
+                return next(lastValue);
+            }
+            const schema = factoryJsonSchema({
+                context: params.contextToJsonSchemaFactory,
+                resultSchemaContext: params.resultSchemaContext,
+                schema: DP.object({
+                    event: DP.literal(eventNameList),
+                    data: DP.union(eventDataList),
+                    id: DP.optional(DP.string()),
+                    retry: DP.optional(DP.number()),
+                }),
+            });
+            const lastContent = lastValue[code]?.content;
+            const content = {
+                ...lastContent,
+                "text/event-stream": {
+                    itemSchema: lastContent?.["text/event-stream"]
+                        ? {
+                            anyOf: [
+                                lastContent["text/event-stream"].itemSchema,
+                                schema,
+                            ],
+                        }
+                        : schema,
+                },
+            };
+            return nextWithObject(lastValue, {
+                [code]: {
+                    headers,
+                    content,
+                },
+            });
+        }
+        const schemaResponse = factoryJsonSchema({
+            context: params.contextToJsonSchemaFactory,
+            resultSchemaContext: params.resultSchemaContext,
+            schema: body,
+        });
         const content = pipe(body, P.when(DP.identifier(DP.emptyKind), justReturn(lastValue[code]?.content)), P.otherwise((value) => {
             if (DP.identifier(value, DP.stringKind) && lastValue[code]?.content?.["plain/text"]) {
                 return lastValue[code].content;

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

@@ -1,19 +1,23 @@
-import type { JsonSchema, JsonSchemaLiteral, JsonSchemaString } from "@duplojs/data-parser-tools/toJsonSchema";
+import type { JsonSchema } from "@duplojs/data-parser-tools/toJsonSchema";
 export interface EndpointResponseHeader {
     information: {
-        schema: JsonSchemaLiteral;
+        schema: JsonSchema;
         description: string;
     };
 }
 export interface EndpointResponseContent {
+    "text/event-stream"?: {
+        itemSchema: JsonSchema;
+    };
     "application/json"?: {
         schema: JsonSchema;
     };
     "plain/text"?: {
-        schema: JsonSchemaString;
+        schema: JsonSchema;
     };
 }
 export interface EndpointResponse {
+    description?: string;
     headers: EndpointResponseHeader;
     content?: EndpointResponseContent;
 }

package/dist/plugins/static/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var makeRouteFolder = require('./makeRouteFolder.cjs');
+var makeRouteFile = require('./makeRouteFile.cjs');
+var plugin = require('./plugin.cjs');
+
+
+
+exports.makeRouteFolder = makeRouteFolder.makeRouteFolder;
+exports.MissingSelectedStaticFileError = makeRouteFile.MissingSelectedStaticFileError;
+exports.SelectedStaticFileIsNotFileError = makeRouteFile.SelectedStaticFileIsNotFileError;
+exports.makeRouteFile = makeRouteFile.makeRouteFile;
+exports.StaticPluginError = plugin.StaticPluginError;
+exports.staticPlugin = plugin.staticPlugin;

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

@@ -0,0 +1,3 @@
+export * from "./makeRouteFolder";
+export * from "./makeRouteFile";
+export * from "./plugin";

package/dist/plugins/static/index.mjs

@@ -0,0 +1,3 @@
+export { makeRouteFolder } from './makeRouteFolder.mjs';
+export { MissingSelectedStaticFileError, SelectedStaticFileIsNotFileError, makeRouteFile } from './makeRouteFile.mjs';
+export { StaticPluginError, staticPlugin } from './plugin.mjs';

package/dist/plugins/static/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createStaticPluginKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsStaticPlugin");
+
+exports.createStaticPluginKind = createStaticPluginKind;

package/dist/plugins/static/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsStaticPlugin: true;
+    }
+}
+export declare const createStaticPluginKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsStaticPlugin/${GenericName}`, GenericKindValue>>;

package/dist/plugins/static/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createStaticPluginKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsStaticPlugin");
+
+export { createStaticPluginKind };

package/dist/plugins/static/makeRouteFile.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var serverUtils = require('@duplojs/server-utils');
+var utils = require('@duplojs/utils');
+require('../../core/builders/index.cjs');
+require('../../core/metadata/index.cjs');
+require('../../core/response/index.cjs');
+var hooks = require('../cacheController/hooks.cjs');
+var kind = require('./kind.cjs');
+var builder = require('../../core/builders/route/builder.cjs');
+var ignoreByRouteStore = require('../../core/metadata/ignoreByRouteStore.cjs');
+var contract = require('../../core/response/contract.cjs');
+
+class MissingSelectedStaticFileError extends utils.kindHeritage("missing-selected-static-file", kind.createStaticPluginKind("missing-selected-static-file"), Error) {
+    source;
+    constructor(source) {
+        super({}, [`Missing selected static file: ${source.path}.`]);
+        this.source = source;
+    }
+}
+class SelectedStaticFileIsNotFileError extends utils.kindHeritage("selected-static-file-is-not-file", kind.createStaticPluginKind("selected-static-file-is-not-file"), Error) {
+    source;
+    constructor(source) {
+        super({}, [`Selected static file is not file: ${source.path}.`]);
+        this.source = source;
+    }
+}
+function makeRouteFile(params) {
+    const localPath = utils.A.coalescing(params.path);
+    return builder.useRouteBuilder("GET", localPath, {
+        metadata: [ignoreByRouteStore.IgnoreByRouteStoreMetadata()],
+        hooks: [hooks.createCacheControllerHooks(params.cacheControlConfig)],
+    })
+        .handler([
+        contract.ResponseContract.ok("resource.found", serverUtils.SDP.file()),
+        contract.ResponseContract.notModified("resource.notModified"),
+    ], async (__, { response, request }) => {
+        const sourceStatResult = await params.source.stat();
+        if (utils.E.isLeft(sourceStatResult)) {
+            throw new MissingSelectedStaticFileError(params.source);
+        }
+        const resourceStat = utils.unwrap(sourceStatResult);
+        if (!resourceStat.isFile) {
+            throw new SelectedStaticFileIsNotFileError(params.source);
+        }
+        if (request.headers["if-modified-since"]
+            && typeof request.headers["if-modified-since"] === "string"
+            && resourceStat.modifiedAt
+            && new Date(request.headers["if-modified-since"]).getTime() >= resourceStat.modifiedAt.getTime()) {
+            return response("resource.notModified")
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString());
+        }
+        return resourceStat.modifiedAt
+            ? response("resource.found", params.source)
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString())
+            : response("resource.found", params.source);
+    });
+}
+
+exports.MissingSelectedStaticFileError = MissingSelectedStaticFileError;
+exports.SelectedStaticFileIsNotFileError = SelectedStaticFileIsNotFileError;
+exports.makeRouteFile = makeRouteFile;

package/dist/plugins/static/makeRouteFile.d.ts

@@ -0,0 +1,48 @@
+import { SDP, type SF } from "@duplojs/server-utils";
+import { type AnyTuple } from "@duplojs/utils";
+import { ResponseContract } from "../../core/response";
+import type { RoutePath } from "../../core/route";
+import { type CacheControlDirectives } from "../cacheController/types";
+interface MakeRouteFileParams {
+    readonly source: SF.FileInterface;
+    readonly path: RoutePath | AnyTuple<RoutePath>;
+    readonly cacheControlConfig?: CacheControlDirectives;
+}
+declare const MissingSelectedStaticFileError_base: new (params: {
+    "@DuplojsStaticPlugin/missing-selected-static-file"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsStaticPlugin/missing-selected-static-file", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"missing-selected-static-file", unknown>, unknown>;
+export declare class MissingSelectedStaticFileError extends MissingSelectedStaticFileError_base {
+    source: SF.FileInterface;
+    constructor(source: SF.FileInterface);
+}
+declare const SelectedStaticFileIsNotFileError_base: new (params: {
+    "@DuplojsStaticPlugin/selected-static-file-is-not-file"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsStaticPlugin/selected-static-file-is-not-file", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"selected-static-file-is-not-file", unknown>, unknown>;
+export declare class SelectedStaticFileIsNotFileError extends SelectedStaticFileIsNotFileError_base {
+    source: SF.FileInterface;
+    constructor(source: SF.FileInterface);
+}
+export declare function makeRouteFile(params: MakeRouteFileParams): import("../../core/route").Route<{
+    readonly method: "GET";
+    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
+    readonly hooks: readonly [{
+        readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>) => import("../../core/route").RouteHookNext;
+    }];
+    readonly paths: readonly [`/${string}`] | AnyTuple<`/${string}`>;
+    readonly preflightSteps: readonly [];
+    readonly bodyController: null;
+    readonly steps: readonly [import("../../core/steps").HandlerStep<{
+        readonly responseContract: [NoInfer<ResponseContract.Contract<"200", "resource.found", SDP.DataParserFile<{
+            readonly mimeType?: RegExp | undefined;
+            readonly errorMessage?: string | undefined;
+            readonly coerce: boolean;
+            readonly minSize?: number | undefined;
+            readonly maxSize?: number | undefined;
+            readonly checkExist: boolean;
+            readonly checkers: readonly [];
+        }>>>, NoInfer<ResponseContract.Contract<"304", "resource.notModified", import("@duplojs/utils/dataParser").DataParserEmpty<import("@duplojs/utils/dataParser").DataParserDefinitionEmpty>>>];
+        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
+        readonly metadata: readonly [];
+    }>];
+}>;
+export {};

package/dist/plugins/static/makeRouteFile.mjs

@@ -0,0 +1,58 @@
+import { SDP } from '@duplojs/server-utils';
+import { kindHeritage, A, E, unwrap } from '@duplojs/utils';
+import '../../core/builders/index.mjs';
+import '../../core/metadata/index.mjs';
+import '../../core/response/index.mjs';
+import { createCacheControllerHooks } from '../cacheController/hooks.mjs';
+import { createStaticPluginKind } from './kind.mjs';
+import { useRouteBuilder } from '../../core/builders/route/builder.mjs';
+import { IgnoreByRouteStoreMetadata } from '../../core/metadata/ignoreByRouteStore.mjs';
+import { ResponseContract } from '../../core/response/contract.mjs';
+
+class MissingSelectedStaticFileError extends kindHeritage("missing-selected-static-file", createStaticPluginKind("missing-selected-static-file"), Error) {
+    source;
+    constructor(source) {
+        super({}, [`Missing selected static file: ${source.path}.`]);
+        this.source = source;
+    }
+}
+class SelectedStaticFileIsNotFileError extends kindHeritage("selected-static-file-is-not-file", createStaticPluginKind("selected-static-file-is-not-file"), Error) {
+    source;
+    constructor(source) {
+        super({}, [`Selected static file is not file: ${source.path}.`]);
+        this.source = source;
+    }
+}
+function makeRouteFile(params) {
+    const localPath = A.coalescing(params.path);
+    return useRouteBuilder("GET", localPath, {
+        metadata: [IgnoreByRouteStoreMetadata()],
+        hooks: [createCacheControllerHooks(params.cacheControlConfig)],
+    })
+        .handler([
+        ResponseContract.ok("resource.found", SDP.file()),
+        ResponseContract.notModified("resource.notModified"),
+    ], async (__, { response, request }) => {
+        const sourceStatResult = await params.source.stat();
+        if (E.isLeft(sourceStatResult)) {
+            throw new MissingSelectedStaticFileError(params.source);
+        }
+        const resourceStat = unwrap(sourceStatResult);
+        if (!resourceStat.isFile) {
+            throw new SelectedStaticFileIsNotFileError(params.source);
+        }
+        if (request.headers["if-modified-since"]
+            && typeof request.headers["if-modified-since"] === "string"
+            && resourceStat.modifiedAt
+            && new Date(request.headers["if-modified-since"]).getTime() >= resourceStat.modifiedAt.getTime()) {
+            return response("resource.notModified")
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString());
+        }
+        return resourceStat.modifiedAt
+            ? response("resource.found", params.source)
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString())
+            : response("resource.found", params.source);
+    });
+}
+
+export { MissingSelectedStaticFileError, SelectedStaticFileIsNotFileError, makeRouteFile };