@duplojs/http 0.7.4 → 0.8.4

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.cjs

@@ -24,11 +24,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         return utils.E.error(new error.BodyParseFormDataError("Wrong boundary."));
     }
     let valueAccumulator = firstValueAccumulator;
-    const startPart = Buffer.from(`\r\n--${boundary}`);
-    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    const startPart = Buffer.from(`\r\n--${boundary}\r\n`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--\r\n`);
     let currentBuffer = bufferStart;
     let size = 0;
-    const keep = endMultiPart.length - 1;
+    const keep = endMultiPart.length;
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
@@ -114,11 +114,6 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 return await treatError(new error.BodyParseFormDataError("Buffer size exceeds limit."));
             }
             while (true) {
-                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
-                if (endMultiPartIndex !== -1) {
-                    // check if buffer contain end of transmissions
-                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
-                }
                 const startPartIndex = currentBuffer.indexOf(startPart);
                 const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
                 if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
@@ -156,9 +151,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 }
             }
         }
-        const resultChunk = await flushReceiveChunk(currentBuffer);
-        if (resultChunk !== true) {
-            return await treatError(resultChunk);
+        if (currentBuffer.indexOf(endMultiPart) === -1) {
+            const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, 2));
+            if (resultChunk !== true) {
+                return await treatError(resultChunk);
+            }
         }
         valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
         return valueAccumulator;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.mjs

@@ -22,11 +22,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         return E.error(new BodyParseFormDataError("Wrong boundary."));
     }
     let valueAccumulator = firstValueAccumulator;
-    const startPart = Buffer.from(`\r\n--${boundary}`);
-    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    const startPart = Buffer.from(`\r\n--${boundary}\r\n`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--\r\n`);
     let currentBuffer = bufferStart;
     let size = 0;
-    const keep = endMultiPart.length - 1;
+    const keep = endMultiPart.length;
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
@@ -112,11 +112,6 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 return await treatError(new BodyParseFormDataError("Buffer size exceeds limit."));
             }
             while (true) {
-                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
-                if (endMultiPartIndex !== -1) {
-                    // check if buffer contain end of transmissions
-                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
-                }
                 const startPartIndex = currentBuffer.indexOf(startPart);
                 const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
                 if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
@@ -154,9 +149,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 }
             }
         }
-        const resultChunk = await flushReceiveChunk(currentBuffer);
-        if (resultChunk !== true) {
-            return await treatError(resultChunk);
+        if (currentBuffer.indexOf(endMultiPart) === -1) {
+            const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, 2));
+            if (resultChunk !== true) {
+                return await treatError(resultChunk);
+            }
         }
         valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
         return valueAccumulator;

package/dist/interfaces/node/createHttpServer.cjs

@@ -2,10 +2,9 @@
 
 var http = require('http');
 var https = require('https');
-var index$3 = require('./hooks/index.cjs');
+var index$2 = 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');
@@ -25,7 +24,6 @@ function createHttpServer(hub, params) {
         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) {
@@ -44,6 +42,7 @@ function createHttpServer(hub, params) {
     return implementHttpServer.implementHttpServer({
         hub,
         httpServerParams,
+        getInterfaceHooks: ({ hub, httpServerParams }) => [index$2.initNodeHook(hub, httpServerParams)],
     }, ({ httpServerParams, execRouteSystem }) => {
         const server = httpServerParams.https
             ? https.createServer(httpServerParams.https)

package/dist/interfaces/node/createHttpServer.mjs

@@ -1,9 +1,8 @@
 import http from 'http';
 import https from 'https';
-import { nodeHook } from './hooks/index.mjs';
+import { initNodeHook } 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';
@@ -23,7 +22,6 @@ function createHttpServer(hub, params) {
         createTextBodyReaderImplementation(httpServerParams),
         createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    hub.addRouteHooks([initDefaultHook(hub, httpServerParams), nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
@@ -42,6 +40,7 @@ function createHttpServer(hub, params) {
     return implementHttpServer({
         hub,
         httpServerParams,
+        getInterfaceHooks: ({ hub, httpServerParams }) => [initNodeHook(hub, httpServerParams)],
     }, ({ httpServerParams, execRouteSystem }) => {
         const server = httpServerParams.https
             ? https.createServer(httpServerParams.https)

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

@@ -1,47 +1,70 @@
 'use strict';
 
+require('../../../core/response/index.cjs');
 require('../../../core/route/index.cjs');
+var serverSentEvents = require('../../../core/serverSentEvents.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');
+var serverSentEventsPredicted = require('../../../core/response/serverSentEventsPredicted.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();
-    },
-});
+function initNodeHook(hub, serverParams) {
+    const isDev = hub.config.environment === "DEV";
+    return 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: rawRequest } = request.raw;
+            if (currentResponse instanceof serverSentEventsPredicted.ServerSentEventsPredictedResponse) {
+                const handler = serverSentEvents.ServerSentEvents.init(currentResponse, {
+                    lastId: typeof request.headers["last-event-id"] === "string"
+                        ? request.headers["last-event-id"]
+                        : null,
+                });
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write(value)) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
+            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;
+exports.initNodeHook = initNodeHook;

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

@@ -1,5 +1,7 @@
-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>;
+import { type Hub } from "../../../core/hub";
+import { type HttpServerParams } from "../../../core/types";
+export declare function initNodeHook(hub: Hub, serverParams: HttpServerParams): {
+    readonly beforeSendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => import("../../../core/route").RouteHookExit;
+    readonly sendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookExit>;
+    readonly afterSendResponse: ({ request, next }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookNext>;
 };

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

@@ -1,45 +1,68 @@
+import '../../../core/response/index.mjs';
 import '../../../core/route/index.mjs';
+import { ServerSentEvents } from '../../../core/serverSentEvents.mjs';
 import { SF } from '@duplojs/server-utils';
 import { A } from '@duplojs/utils';
 import { createReadStream } from 'node:fs';
 import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
+import { ServerSentEventsPredictedResponse } from '../../../core/response/serverSentEventsPredicted.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();
-    },
-});
+function initNodeHook(hub, serverParams) {
+    const isDev = hub.config.environment === "DEV";
+    return 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: rawRequest } = request.raw;
+            if (currentResponse instanceof ServerSentEventsPredictedResponse) {
+                const handler = ServerSentEvents.init(currentResponse, {
+                    lastId: typeof request.headers["last-event-id"] === "string"
+                        ? request.headers["last-event-id"]
+                        : null,
+                });
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write(value)) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
+            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 };
+export { initNodeHook };

package/dist/interfaces/node/index.cjs

@@ -15,7 +15,7 @@ var index$2 = require('./bodyReaders/text/index.cjs');
 
 exports.createInterfacesNodeLibKind = kind.createInterfacesNodeLibKind;
 exports.createHttpServer = createHttpServer.createHttpServer;
-exports.nodeHook = index.nodeHook;
+exports.initNodeHook = index.initNodeHook;
 exports.BodyParseFormDataError = error.BodyParseFormDataError;
 exports.readRequestFormData = readRequestFormData.readRequestFormData;
 exports.createFormDataBodyReaderImplementation = index$1.createFormDataBodyReaderImplementation;

package/dist/interfaces/node/index.mjs

@@ -1,7 +1,7 @@
 import './types/index.mjs';
 export { createInterfacesNodeLibKind } from './kind.mjs';
 export { createHttpServer } from './createHttpServer.mjs';
-export { nodeHook } from './hooks/index.mjs';
+export { initNodeHook } from './hooks/index.mjs';
 import './bodyReaders/index.mjs';
 export { BodyParseFormDataError } from './bodyReaders/formData/error.mjs';
 export { readRequestFormData } from './bodyReaders/formData/readRequestFormData.mjs';

package/dist/plugins/cacheController/createResponseHeader.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createCacheControlResponseHeader(directives) {
+    return utils.pipe([
+        utils.O.entry("max-age", directives.maxAge),
+        utils.O.entry("s-maxage", directives.sMaxAge),
+        utils.O.entry("public", directives.public),
+        utils.O.entry("private", directives.private),
+        utils.O.entry("no-cache", directives.noCache),
+        utils.O.entry("no-store", directives.noStore),
+        utils.O.entry("no-transform", directives.noTransform),
+        utils.O.entry("must-revalidate", directives.mustRevalidate),
+        utils.O.entry("proxy-revalidate", directives.proxyRevalidate),
+        utils.O.entry("immutable", directives.immutable),
+        utils.O.entry("stale-while-revalidate", directives.staleWhileRevalidate),
+        utils.O.entry("stale-if-error", directives.staleIfError),
+        utils.O.entry("must-understand", directives.mustUnderstand),
+    ], utils.A.concat(directives.extensions ? utils.O.entries(directives.extensions) : []), utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, nextPush, next }) => {
+        if (value === true) {
+            return nextPush(lastValue, key);
+        }
+        else if (typeof value === "number"
+            && Number.isFinite(value)
+            && value >= 0) {
+            return nextPush(lastValue, `${key}=${Math.trunc(value)}`);
+        }
+        else if (value instanceof Array
+            && utils.A.minElements(value, 1)) {
+            return nextPush(lastValue, `${key}="${utils.A.join(value, ",")}"`);
+        }
+        else if (value !== ""
+            && typeof value === "string") {
+            return nextPush(lastValue, `${key}="${value}"`);
+        }
+        else {
+            return next(lastValue);
+        }
+    }), utils.A.join(","));
+}
+
+exports.createCacheControlResponseHeader = createCacheControlResponseHeader;

package/dist/plugins/cacheController/createResponseHeader.d.ts

@@ -0,0 +1,2 @@
+import type { CacheControlDirectives } from "./types";
+export declare function createCacheControlResponseHeader(directives: CacheControlDirectives): string;

package/dist/plugins/cacheController/createResponseHeader.mjs

@@ -0,0 +1,41 @@
+import { pipe, O, A } from '@duplojs/utils';
+
+function createCacheControlResponseHeader(directives) {
+    return pipe([
+        O.entry("max-age", directives.maxAge),
+        O.entry("s-maxage", directives.sMaxAge),
+        O.entry("public", directives.public),
+        O.entry("private", directives.private),
+        O.entry("no-cache", directives.noCache),
+        O.entry("no-store", directives.noStore),
+        O.entry("no-transform", directives.noTransform),
+        O.entry("must-revalidate", directives.mustRevalidate),
+        O.entry("proxy-revalidate", directives.proxyRevalidate),
+        O.entry("immutable", directives.immutable),
+        O.entry("stale-while-revalidate", directives.staleWhileRevalidate),
+        O.entry("stale-if-error", directives.staleIfError),
+        O.entry("must-understand", directives.mustUnderstand),
+    ], A.concat(directives.extensions ? O.entries(directives.extensions) : []), A.reduce(A.reduceFrom([]), ({ element: [key, value], lastValue, nextPush, next }) => {
+        if (value === true) {
+            return nextPush(lastValue, key);
+        }
+        else if (typeof value === "number"
+            && Number.isFinite(value)
+            && value >= 0) {
+            return nextPush(lastValue, `${key}=${Math.trunc(value)}`);
+        }
+        else if (value instanceof Array
+            && A.minElements(value, 1)) {
+            return nextPush(lastValue, `${key}="${A.join(value, ",")}"`);
+        }
+        else if (value !== ""
+            && typeof value === "string") {
+            return nextPush(lastValue, `${key}="${value}"`);
+        }
+        else {
+            return next(lastValue);
+        }
+    }), A.join(","));
+}
+
+export { createCacheControlResponseHeader };

package/dist/plugins/cacheController/hooks.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var createResponseHeader = require('./createResponseHeader.cjs');
+require('../../core/route/index.cjs');
+var hooks = require('../../core/route/hooks.cjs');
+
+const eligibleCodeRegex = /^(?:2|3)/;
+function createCacheControllerHooks(params) {
+    const cacheControl = params
+        ? createResponseHeader.createCacheControlResponseHeader(params)
+        : null;
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (cacheControl
+                && eligibleCodeRegex.test(currentResponse.code)) {
+                currentResponse.setHeader("cache-control", cacheControl);
+            }
+            return next();
+        },
+    });
+}
+
+exports.createCacheControllerHooks = createCacheControllerHooks;

package/dist/plugins/cacheController/hooks.d.ts

@@ -0,0 +1,4 @@
+import type { CacheControlDirectives } from "./types";
+export declare function createCacheControllerHooks(params?: CacheControlDirectives): {
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>) => import("../../core/route").RouteHookNext;
+};

package/dist/plugins/cacheController/hooks.mjs

@@ -0,0 +1,21 @@
+import { createCacheControlResponseHeader } from './createResponseHeader.mjs';
+import '../../core/route/index.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
+
+const eligibleCodeRegex = /^(?:2|3)/;
+function createCacheControllerHooks(params) {
+    const cacheControl = params
+        ? createCacheControlResponseHeader(params)
+        : null;
+    return createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (cacheControl
+                && eligibleCodeRegex.test(currentResponse.code)) {
+                currentResponse.setHeader("cache-control", cacheControl);
+            }
+            return next();
+        },
+    });
+}
+
+export { createCacheControllerHooks };

package/dist/plugins/cacheController/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+require('./types/index.cjs');
+var createResponseHeader = require('./createResponseHeader.cjs');
+
+
+
+exports.createCacheControllerHooks = hooks.createCacheControllerHooks;
+exports.createCacheControlResponseHeader = createResponseHeader.createCacheControlResponseHeader;

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

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./types";
+export * from "./createResponseHeader";

package/dist/plugins/cacheController/index.mjs

@@ -0,0 +1,3 @@
+export { createCacheControllerHooks } from './hooks.mjs';
+import './types/index.mjs';
+export { createCacheControlResponseHeader } from './createResponseHeader.mjs';

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,