@duplojs/http 0.7.1 → 0.8.4

package/dist/core/router/buildSystemRoute.mjs

@@ -0,0 +1,31 @@
+import { asyncPipe, E, unwrap } from '@duplojs/utils';
+import '../functionsBuilders/index.mjs';
+import '../request/index.mjs';
+import { createRoute } from '../route/index.mjs';
+import { RouterBuildError } from './buildError.mjs';
+import { defaultEmptyReaderImplementation } from '../hub/defaultEmptyReaderImplementation.mjs';
+import { controlBodyAsEmpty } from '../request/bodyController/empty.mjs';
+import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+
+async function buildSystemRoute(params) {
+    const bodyController = controlBodyAsEmpty();
+    const bodyReader = bodyController.createReaderOrThrow(defaultEmptyReaderImplementation);
+    const route = createRoute({
+        method: "GET",
+        paths: ["/"],
+        hooks: [],
+        preflightSteps: [],
+        steps: [params.handlerStep],
+        metadata: [],
+        bodyController,
+    });
+    const buildedRoute = await asyncPipe(buildRouteFunction(route, params.buildParams), E.whenIsLeft((element) => {
+        throw new RouterBuildError(route, element);
+    }), unwrap);
+    return {
+        bodyReader,
+        buildedRoute,
+    };
+}
+
+export { buildSystemRoute };

package/dist/core/router/decodeUrl.cjs

@@ -2,6 +2,7 @@
 
 const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
 const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
 function decodeUrl(url) {
     try {
         const groups = regexUrlAnalyser.exec(url).groups;
@@ -17,6 +18,9 @@ function decodeUrl(url) {
         for (const result of queryString.matchAll(regexQueryAnalyser)) {
             const groups = result.groups;
             const key = decodeURIComponent(groups.key);
+            if (invalidEntryRegex.test(key)) {
+                continue;
+            }
             const value = decodeURIComponent(groups.value);
             const currentValue = query[key];
             if (typeof currentValue === "undefined") {
@@ -35,10 +39,7 @@ function decodeUrl(url) {
         };
     }
     catch {
-        return {
-            path: "/",
-            query: {},
-        };
+        return null;
     }
 }
 

package/dist/core/router/decodeUrl.d.ts

@@ -4,4 +4,4 @@ export interface DecodedUrl {
     path: string;
     query: Record<string, string | string[]>;
 }
-export declare function decodeUrl(url: string): DecodedUrl;
+export declare function decodeUrl(url: string): DecodedUrl | null;

package/dist/core/router/decodeUrl.mjs

@@ -1,5 +1,6 @@
 const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
 const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
 function decodeUrl(url) {
     try {
         const groups = regexUrlAnalyser.exec(url).groups;
@@ -15,6 +16,9 @@ function decodeUrl(url) {
         for (const result of queryString.matchAll(regexQueryAnalyser)) {
             const groups = result.groups;
             const key = decodeURIComponent(groups.key);
+            if (invalidEntryRegex.test(key)) {
+                continue;
+            }
             const value = decodeURIComponent(groups.value);
             const currentValue = query[key];
             if (typeof currentValue === "undefined") {
@@ -33,10 +37,7 @@ function decodeUrl(url) {
         };
     }
     catch {
-        return {
-            path: "/",
-            query: {},
-        };
+        return null;
     }
 }
 

package/dist/core/router/index.cjs

@@ -3,13 +3,12 @@
 require('../hub/index.cjs');
 var utils = require('@duplojs/utils');
 var pathToRegExp = require('./pathToRegExp.cjs');
-var index = require('../route/index.cjs');
 var buildError = require('./buildError.cjs');
 require('../functionsBuilders/route/index.cjs');
 var decodeUrl = require('./decodeUrl.cjs');
-var text = require('../request/bodyController/text.cjs');
 var notFoundBodyReaderImplementationError = require('./notFoundBodyReaderImplementationError.cjs');
 require('../functionsBuilders/index.cjs');
+var buildSystemRoute = require('./buildSystemRoute.cjs');
 require('./types/index.cjs');
 var _default = require('../functionsBuilders/route/default.cjs');
 var checkerStep = require('../functionsBuilders/steps/defaults/checkerStep.cjs');
@@ -63,35 +62,36 @@ async function buildRouter(hub) {
             }))),
         });
     });
-    const bodyControllerNotfoundRoute = text.controlBodyAsText();
-    const bodyReaderNotFoundRoute = utils.unwrap(bodyControllerNotfoundRoute.tryToCreateReader(text.TextBodyController.createReaderImplementation(() => Promise.resolve(utils.E.error(new Error("Inaccessible body in not found route."))))));
-    utils.asserts(bodyReaderNotFoundRoute, utils.isType("object"));
-    const buildedNotfoundRoute = await utils.asyncPipe(index.createRoute({
-        method: "GET",
-        paths: ["/"],
-        hooks: [],
-        preflightSteps: [],
-        steps: [hub.notfoundHandler],
-        metadata: [],
-        bodyController: bodyControllerNotfoundRoute,
-    }), async (route) => {
-        const result = await build.buildRouteFunction(route, buildParams);
-        return utils.E.whenIsLeft(result, (element) => {
-            throw new buildError.RouterBuildError(route, element);
-        });
-    }, utils.unwrap);
+    const defaultNotfoundRoute = await buildSystemRoute.buildSystemRoute({
+        handlerStep: hub.notfoundHandler,
+        buildParams,
+    });
+    const defaultMalformedUrlRoute = await buildSystemRoute.buildSystemRoute({
+        handlerStep: hub.malformedUrlHandler,
+        buildParams,
+    });
     const Request = hub.classRequest;
     return {
         exec: (initializationData) => {
             const routerElements = groupedRoute[initializationData.method];
             const decodedUrl = decodeUrl.decodeUrl(initializationData.url);
+            if (!decodedUrl) {
+                return defaultMalformedUrlRoute.buildedRoute(new Request({
+                    ...initializationData,
+                    params: {},
+                    path: "",
+                    query: {},
+                    matchedPath: null,
+                    bodyReader: defaultMalformedUrlRoute.bodyReader,
+                }));
+            }
             if (!routerElements) {
-                return buildedNotfoundRoute(new Request({
+                return defaultNotfoundRoute.buildedRoute(new Request({
                     ...initializationData,
                     ...decodedUrl,
                     params: {},
                     matchedPath: null,
-                    bodyReader: bodyReaderNotFoundRoute,
+                    bodyReader: defaultNotfoundRoute.bodyReader,
                 }));
             }
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
@@ -109,12 +109,12 @@ async function buildRouter(hub) {
                     bodyReader: routerElement.bodyReader,
                 }));
             }
-            return buildedNotfoundRoute(new Request({
+            return defaultNotfoundRoute.buildedRoute(new Request({
                 ...initializationData,
                 ...decodedUrl,
                 params: {},
                 matchedPath: null,
-                bodyReader: bodyReaderNotFoundRoute,
+                bodyReader: defaultNotfoundRoute.bodyReader,
             }));
         },
         hooksRouteLifeCycle,
@@ -131,4 +131,5 @@ exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
 exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
+exports.buildSystemRoute = buildSystemRoute.buildSystemRoute;
 exports.buildRouter = buildRouter;

package/dist/core/router/index.d.ts

@@ -5,4 +5,5 @@ export * from "./pathToRegExp";
 export * from "./buildError";
 export * from "./decodeUrl";
 export * from "./notFoundBodyReaderImplementationError";
+export * from "./buildSystemRoute";
 export declare function buildRouter(hub: Hub): Promise<BuildedRouter>;

package/dist/core/router/index.mjs

@@ -1,14 +1,13 @@
 import '../hub/index.mjs';
-import { pipe, A, isType, G, E, unwrap, justReturn, O, forward, asserts, asyncPipe } from '@duplojs/utils';
+import { pipe, A, isType, G, E, unwrap, justReturn, O, forward } from '@duplojs/utils';
 import { pathToRegExp } from './pathToRegExp.mjs';
-import { createRoute } from '../route/index.mjs';
 import { RouterBuildError } from './buildError.mjs';
 import '../functionsBuilders/route/index.mjs';
 import { decodeUrl } from './decodeUrl.mjs';
 export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
-import { controlBodyAsText, TextBodyController } from '../request/bodyController/text.mjs';
 import { NotFoundBodyReaderImplementationError } from './notFoundBodyReaderImplementationError.mjs';
 import '../functionsBuilders/index.mjs';
+import { buildSystemRoute } from './buildSystemRoute.mjs';
 import './types/index.mjs';
 import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
 import { defaultCheckerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/checkerStep.mjs';
@@ -62,35 +61,36 @@ async function buildRouter(hub) {
             }))),
         });
     });
-    const bodyControllerNotfoundRoute = controlBodyAsText();
-    const bodyReaderNotFoundRoute = unwrap(bodyControllerNotfoundRoute.tryToCreateReader(TextBodyController.createReaderImplementation(() => Promise.resolve(E.error(new Error("Inaccessible body in not found route."))))));
-    asserts(bodyReaderNotFoundRoute, isType("object"));
-    const buildedNotfoundRoute = await asyncPipe(createRoute({
-        method: "GET",
-        paths: ["/"],
-        hooks: [],
-        preflightSteps: [],
-        steps: [hub.notfoundHandler],
-        metadata: [],
-        bodyController: bodyControllerNotfoundRoute,
-    }), async (route) => {
-        const result = await buildRouteFunction(route, buildParams);
-        return E.whenIsLeft(result, (element) => {
-            throw new RouterBuildError(route, element);
-        });
-    }, unwrap);
+    const defaultNotfoundRoute = await buildSystemRoute({
+        handlerStep: hub.notfoundHandler,
+        buildParams,
+    });
+    const defaultMalformedUrlRoute = await buildSystemRoute({
+        handlerStep: hub.malformedUrlHandler,
+        buildParams,
+    });
     const Request = hub.classRequest;
     return {
         exec: (initializationData) => {
             const routerElements = groupedRoute[initializationData.method];
             const decodedUrl = decodeUrl(initializationData.url);
+            if (!decodedUrl) {
+                return defaultMalformedUrlRoute.buildedRoute(new Request({
+                    ...initializationData,
+                    params: {},
+                    path: "",
+                    query: {},
+                    matchedPath: null,
+                    bodyReader: defaultMalformedUrlRoute.bodyReader,
+                }));
+            }
             if (!routerElements) {
-                return buildedNotfoundRoute(new Request({
+                return defaultNotfoundRoute.buildedRoute(new Request({
                     ...initializationData,
                     ...decodedUrl,
                     params: {},
                     matchedPath: null,
-                    bodyReader: bodyReaderNotFoundRoute,
+                    bodyReader: defaultNotfoundRoute.bodyReader,
                 }));
             }
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
@@ -108,12 +108,12 @@ async function buildRouter(hub) {
                     bodyReader: routerElement.bodyReader,
                 }));
             }
-            return buildedNotfoundRoute(new Request({
+            return defaultNotfoundRoute.buildedRoute(new Request({
                 ...initializationData,
                 ...decodedUrl,
                 params: {},
                 matchedPath: null,
-                bodyReader: bodyReaderNotFoundRoute,
+                bodyReader: defaultNotfoundRoute.bodyReader,
             }));
         },
         hooksRouteLifeCycle,
@@ -124,4 +124,4 @@ async function buildRouter(hub) {
     };
 }
 
-export { NotFoundBodyReaderImplementationError, RouterBuildError, buildRouter, decodeUrl, pathToRegExp };
+export { NotFoundBodyReaderImplementationError, RouterBuildError, buildRouter, buildSystemRoute, decodeUrl, pathToRegExp };

package/dist/core/serverSentEvents.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+exports.ServerSentEvents = void 0;
+(function (ServerSentEvents) {
+    const regexServerSentEventSplitStringData = /\r\n|\r|\n/;
+    const nullIdRegexp = /\0|\n|\r/;
+    function init(response, initParams) {
+        const abortSubscribers = [];
+        let isAbort = false;
+        const handler = {
+            async start(send, close) {
+                if (isAbort) {
+                    return;
+                }
+                let isClose = false;
+                const closeSubscribers = [];
+                const errorSubscribers = [];
+                const params = {
+                    send: (event, data, params) => {
+                        if (isClose) {
+                            return Promise.resolve();
+                        }
+                        else if (isAbort) {
+                            return Promise.resolve();
+                        }
+                        let content = `event: ${event || "message"}\n`;
+                        if (typeof data === "string") {
+                            const splitData = data.split(regexServerSentEventSplitStringData);
+                            for (let index = 0; index < splitData.length; index++) {
+                                content += `data: ${splitData[index]}\n`;
+                            }
+                        }
+                        else if (data !== undefined) {
+                            content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
+                        }
+                        if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
+                            content += `id: ${params.id}\n`;
+                        }
+                        if (params?.retry !== undefined) {
+                            content += `retry: ${utils.stringToMillisecond(params.retry)}\n`;
+                        }
+                        content += "\n";
+                        return send(content);
+                    },
+                    abort: handler.abort,
+                    isAbort: () => isAbort,
+                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
+                    close: () => {
+                        if (isClose === true) {
+                            return;
+                        }
+                        isClose = true;
+                        close();
+                        for (let index = 0; index < closeSubscribers.length; index++) {
+                            closeSubscribers[index]();
+                        }
+                    },
+                    isClose: () => isClose,
+                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
+                    error: (error) => {
+                        for (let index = 0; index < errorSubscribers.length; index++) {
+                            errorSubscribers[index](error);
+                        }
+                    },
+                    onError: (theFunction) => void errorSubscribers.push(theFunction),
+                    lastId: initParams.lastId && !nullIdRegexp.test(initParams.lastId)
+                        ? initParams.lastId
+                        : null,
+                };
+                try {
+                    await response.startSendingEvents(params);
+                }
+                catch (error) {
+                    params.error(error);
+                }
+                finally {
+                    params.close();
+                }
+            },
+            abort() {
+                if (isAbort === true) {
+                    return;
+                }
+                isAbort = true;
+                for (let index = 0; index < abortSubscribers.length; index++) {
+                    abortSubscribers[index]();
+                }
+            },
+        };
+        return handler;
+    }
+    ServerSentEvents.init = init;
+})(exports.ServerSentEvents || (exports.ServerSentEvents = {}));

package/dist/core/serverSentEvents.d.ts

@@ -0,0 +1,33 @@
+import { type MillisecondInString } from "@duplojs/utils";
+import { type ServerSentEventsPredictedResponse } from "./response";
+export declare namespace ServerSentEvents {
+    type DefinitionShape = [string, unknown];
+    interface SendParams {
+        id?: string;
+        retry?: number | MillisecondInString;
+    }
+    interface StartSendingParams<GenericEvents extends DefinitionShape = DefinitionShape> {
+        send(...args: GenericEvents extends any ? [
+            event: GenericEvents[0],
+            ...(GenericEvents[1] extends undefined ? [data?: GenericEvents[1]] : [data: GenericEvents[1]]),
+            params?: SendParams
+        ] : never): Promise<void>;
+        abort(): void;
+        onAbort(theFunction: () => void): void;
+        isAbort(): boolean;
+        close(): void;
+        onClose(theFunction: () => void): void;
+        isClose(): boolean;
+        error(error: unknown): void;
+        onError(theFunction: (error: unknown) => void): void;
+        readonly lastId: string | null;
+    }
+    interface Handler {
+        start(send: (value: string) => Promise<void>, close: () => void): Promise<void>;
+        abort(): void;
+    }
+    interface InitParams {
+        readonly lastId: string | null;
+    }
+    function init(response: ServerSentEventsPredictedResponse, initParams: InitParams): Handler;
+}

package/dist/core/serverSentEvents.mjs

@@ -0,0 +1,96 @@
+import { stringToMillisecond } from '@duplojs/utils';
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+var ServerSentEvents;
+(function (ServerSentEvents) {
+    const regexServerSentEventSplitStringData = /\r\n|\r|\n/;
+    const nullIdRegexp = /\0|\n|\r/;
+    function init(response, initParams) {
+        const abortSubscribers = [];
+        let isAbort = false;
+        const handler = {
+            async start(send, close) {
+                if (isAbort) {
+                    return;
+                }
+                let isClose = false;
+                const closeSubscribers = [];
+                const errorSubscribers = [];
+                const params = {
+                    send: (event, data, params) => {
+                        if (isClose) {
+                            return Promise.resolve();
+                        }
+                        else if (isAbort) {
+                            return Promise.resolve();
+                        }
+                        let content = `event: ${event || "message"}\n`;
+                        if (typeof data === "string") {
+                            const splitData = data.split(regexServerSentEventSplitStringData);
+                            for (let index = 0; index < splitData.length; index++) {
+                                content += `data: ${splitData[index]}\n`;
+                            }
+                        }
+                        else if (data !== undefined) {
+                            content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
+                        }
+                        if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
+                            content += `id: ${params.id}\n`;
+                        }
+                        if (params?.retry !== undefined) {
+                            content += `retry: ${stringToMillisecond(params.retry)}\n`;
+                        }
+                        content += "\n";
+                        return send(content);
+                    },
+                    abort: handler.abort,
+                    isAbort: () => isAbort,
+                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
+                    close: () => {
+                        if (isClose === true) {
+                            return;
+                        }
+                        isClose = true;
+                        close();
+                        for (let index = 0; index < closeSubscribers.length; index++) {
+                            closeSubscribers[index]();
+                        }
+                    },
+                    isClose: () => isClose,
+                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
+                    error: (error) => {
+                        for (let index = 0; index < errorSubscribers.length; index++) {
+                            errorSubscribers[index](error);
+                        }
+                    },
+                    onError: (theFunction) => void errorSubscribers.push(theFunction),
+                    lastId: initParams.lastId && !nullIdRegexp.test(initParams.lastId)
+                        ? initParams.lastId
+                        : null,
+                };
+                try {
+                    await response.startSendingEvents(params);
+                }
+                catch (error) {
+                    params.error(error);
+                }
+                finally {
+                    params.close();
+                }
+            },
+            abort() {
+                if (isAbort === true) {
+                    return;
+                }
+                isAbort = true;
+                for (let index = 0; index < abortSubscribers.length; index++) {
+                    abortSubscribers[index]();
+                }
+            },
+        };
+        return handler;
+    }
+    ServerSentEvents.init = init;
+})(ServerSentEvents || (ServerSentEvents = {}));
+
+export { ServerSentEvents };

package/dist/core/steps/cut.d.ts

@@ -1,4 +1,4 @@
-import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing } from "@duplojs/utils";
+import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing, type MaybeArray } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
@@ -13,7 +13,7 @@ export interface CutStepFunctionParams<GenericRequest extends Request = Request,
 }
 export interface CutStepDefinition {
     theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | PredictedResponse>;
-    readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    readonly responseContract: MaybeArray<ResponseContract.Contract>;
     readonly metadata: readonly Metadata[];
 }
 export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;

package/dist/core/steps/handler.d.ts

@@ -1,15 +1,20 @@
-import { type MaybePromise, type Kind } from "@duplojs/utils";
+import { type MaybePromise, type Kind, type MaybeArray } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
-import { type PredictedResponse, type ResponseContract } from "../response";
+import { type ServerSentEventsPredictedResponse, type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
 import { type Metadata } from "../metadata";
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
+interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse extends ServerSentEventsPredictedResponse> {
+    serverSentEventsResponse<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
+        information: GenericInformation;
+    }>>(information: GenericInformation, startSendingEvents: GenericFilteredResponse["startSendingEvents"]): GenericFilteredResponse;
+}
+export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<GenericRequest, Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
 }
 export interface HandlerStepDefinition {
-    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse>;
-    readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse | ServerSentEventsPredictedResponse>;
+    readonly responseContract: MaybeArray<ResponseContract.Contract | ResponseContract.ServerSentEventsContract>;
     readonly metadata: readonly Metadata[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;

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

@@ -4,14 +4,39 @@ require('../../../../core/request/index.cjs');
 var serverUtils = require('@duplojs/server-utils');
 var utils = require('@duplojs/utils');
 var readRequestFormData = require('./readRequestFormData.cjs');
-var node_fs = require('node:fs');
+var node_crypto = require('node:crypto');
 require('../../../../core/errors/index.cjs');
+var promises = require('node:fs/promises');
 var error = require('./error.cjs');
 var formData = require('../../../../core/request/bodyController/formData.cjs');
 var wrongContentTypeError = require('../../../../core/errors/wrongContentTypeError.cjs');
 
 function createFormDataBodyReaderImplementation(serverParams) {
     const serverMaxBodySize = utils.stringToBytes(serverParams.maxBodySize);
+    async function createUploadFile(extension, highWaterMark) {
+        let remainingAttempts = 5;
+        do {
+            const path = utils.Path.resolveRelative([
+                serverParams.uploadFolder,
+                `${node_crypto.randomUUID()}${extension}`,
+            ]);
+            try {
+                const handle = await promises.open(path, "wx");
+                return {
+                    path,
+                    writeStream: handle.createWriteStream({
+                        highWaterMark,
+                        autoClose: true,
+                    }),
+                };
+            }
+            catch (error) {
+                if (error.code !== "EEXIST" || --remainingAttempts === 0) {
+                    throw error;
+                }
+            }
+        } while (true);
+    }
     function addValue(mapResult, fieldName, newValue) {
         const value = mapResult.get(fieldName);
         if (value === undefined) {
@@ -34,32 +59,26 @@ function createFormDataBodyReaderImplementation(serverParams) {
             mimeType: params.mimeType,
             maxBufferSize: params.maxBufferSize,
             maxKeyLength: params.maxKeyLength,
-        }, (header) => {
+        }, async (header) => {
             const fieldName = header.name;
             if (header.filename) {
                 const extension = utils.Path.getExtensionName(header.filename);
                 const displayExtension = extension ? `.${extension}` : "";
-                const filePath = utils.Path.resolveRelative([
-                    serverParams.uploadFolder,
-                    `${Math.random().toString(36).slice(2, 10)}-${Date.now()}${displayExtension}`,
-                ]);
-                filesAttache.push(filePath);
-                const currentFile = node_fs.createWriteStream(filePath, {
-                    highWaterMark: request.raw.request.readableHighWaterMark,
-                });
+                const { path, writeStream } = await createUploadFile(displayExtension, request.raw.request.readableHighWaterMark);
+                filesAttache.push(path);
                 return {
-                    onReceiveChunk: (chunk) => new Promise((resolve, reject) => void currentFile.write(chunk, (result) => {
+                    onReceiveChunk: (chunk) => new Promise((resolve, reject) => void writeStream.write(chunk, (result) => {
                         if (result instanceof Error) {
                             return void reject(result);
                         }
                         return void resolve();
                     })),
                     onEndPart: (valueAccumulator) => {
-                        currentFile.end();
-                        addValue(valueAccumulator, fieldName, serverUtils.SF.createFileInterface(currentFile.path.toString()));
+                        writeStream.end();
+                        addValue(valueAccumulator, fieldName, serverUtils.SF.createFileInterface(path));
                         return valueAccumulator;
                     },
-                    onError: () => void currentFile.end(),
+                    onError: () => void writeStream.end(),
                 };
             }
             let currentValue = "";