@duplojs/http 0.7.4 → 0.8.5

package/dist/plugins/static/makeRouteFolder.cjs

@@ -0,0 +1,67 @@
+'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 builder = require('../../core/builders/route/builder.cjs');
+var ignoreByRouteStore = require('../../core/metadata/ignoreByRouteStore.cjs');
+var contract = require('../../core/response/contract.cjs');
+
+function makeRouteFolder(params) {
+    const sourcePath = utils.whenNot(params.source.path, utils.S.endsWith("/"), utils.S.concat("/"));
+    const localPrefix = utils.A.coalescing(params.prefix);
+    const routePath = utils.A.mapTuple(localPrefix, (prefix) => `${prefix}/*`);
+    const prefixRegex = utils.pipe(localPrefix, utils.A.map(utils.escapeRegExp), utils.A.join("|"), (value) => new RegExp(`^(?:${value})(?:/|$)`));
+    const getResourcePath = utils.innerPipe(utils.S.replace(prefixRegex, ""), utils.S.prepend(sourcePath));
+    return builder.useRouteBuilder("GET", routePath, {
+        metadata: [ignoreByRouteStore.IgnoreByRouteStoreMetadata()],
+        hooks: [hooks.createCacheControllerHooks(params.cacheControlConfig)],
+    })
+        .handler([
+        contract.ResponseContract.ok("resource.found", serverUtils.SDP.file()),
+        contract.ResponseContract.notFound("resource.notfound"),
+        contract.ResponseContract.notModified("resource.notModified"),
+    ], async (__, { request, response }) => {
+        if (!utils.Path.isAbsolute(request.path)) {
+            return response("resource.notfound");
+        }
+        const resourcePath = getResourcePath(request.path);
+        const resultStat = await serverUtils.SF.stat(resourcePath);
+        if (utils.E.isLeft(resultStat)) {
+            return response("resource.notfound");
+        }
+        const stat = utils.unwrap(resultStat);
+        if (stat.isDirectory && !params.directoryFallBackFile) {
+            return response("resource.notfound");
+        }
+        const resource = serverUtils.SF.createFileInterface(stat.isDirectory && params.directoryFallBackFile
+            ? `${resourcePath}/${params.directoryFallBackFile}`
+            : resourcePath);
+        const resultResourceStat = stat.isFile
+            ? stat
+            : await resource.stat();
+        if (utils.E.isLeft(resultResourceStat)) {
+            return response("resource.notfound");
+        }
+        const resourceStat = utils.unwrap(resultResourceStat);
+        if (!resourceStat.isFile) {
+            return response("resource.notfound");
+        }
+        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", resource)
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString())
+            : response("resource.found", resource);
+    });
+}
+
+exports.makeRouteFolder = makeRouteFolder;

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

@@ -0,0 +1,39 @@
+import { SDP, 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 MakeRouteFolderParams {
+    readonly source: SF.FolderInterface;
+    readonly prefix: RoutePath | AnyTuple<RoutePath>;
+    readonly cacheControlConfig?: CacheControlDirectives;
+    readonly directoryFallBackFile?: string;
+}
+export declare function makeRouteFolder(params: MakeRouteFolderParams): 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: [`/${string}/*`] | [`/${string}/*`, ...`/${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<"404", "resource.notfound", import("@duplojs/utils/dataParser").DataParserEmpty<{
+            readonly errorMessage?: string | undefined;
+            readonly coerce: 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<"404", "resource.notfound", undefined> | 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<"404", "resource.notfound", undefined> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
+        readonly metadata: readonly [];
+    }>];
+}>;
+export {};

package/dist/plugins/static/makeRouteFolder.mjs

@@ -0,0 +1,65 @@
+import { SDP, SF } from '@duplojs/server-utils';
+import { whenNot, S, A, pipe, escapeRegExp, innerPipe, Path, 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 { useRouteBuilder } from '../../core/builders/route/builder.mjs';
+import { IgnoreByRouteStoreMetadata } from '../../core/metadata/ignoreByRouteStore.mjs';
+import { ResponseContract } from '../../core/response/contract.mjs';
+
+function makeRouteFolder(params) {
+    const sourcePath = whenNot(params.source.path, S.endsWith("/"), S.concat("/"));
+    const localPrefix = A.coalescing(params.prefix);
+    const routePath = A.mapTuple(localPrefix, (prefix) => `${prefix}/*`);
+    const prefixRegex = pipe(localPrefix, A.map(escapeRegExp), A.join("|"), (value) => new RegExp(`^(?:${value})(?:/|$)`));
+    const getResourcePath = innerPipe(S.replace(prefixRegex, ""), S.prepend(sourcePath));
+    return useRouteBuilder("GET", routePath, {
+        metadata: [IgnoreByRouteStoreMetadata()],
+        hooks: [createCacheControllerHooks(params.cacheControlConfig)],
+    })
+        .handler([
+        ResponseContract.ok("resource.found", SDP.file()),
+        ResponseContract.notFound("resource.notfound"),
+        ResponseContract.notModified("resource.notModified"),
+    ], async (__, { request, response }) => {
+        if (!Path.isAbsolute(request.path)) {
+            return response("resource.notfound");
+        }
+        const resourcePath = getResourcePath(request.path);
+        const resultStat = await SF.stat(resourcePath);
+        if (E.isLeft(resultStat)) {
+            return response("resource.notfound");
+        }
+        const stat = unwrap(resultStat);
+        if (stat.isDirectory && !params.directoryFallBackFile) {
+            return response("resource.notfound");
+        }
+        const resource = SF.createFileInterface(stat.isDirectory && params.directoryFallBackFile
+            ? `${resourcePath}/${params.directoryFallBackFile}`
+            : resourcePath);
+        const resultResourceStat = stat.isFile
+            ? stat
+            : await resource.stat();
+        if (E.isLeft(resultResourceStat)) {
+            return response("resource.notfound");
+        }
+        const resourceStat = unwrap(resultResourceStat);
+        if (!resourceStat.isFile) {
+            return response("resource.notfound");
+        }
+        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", resource)
+                .setHeader("last-modified", resourceStat.modifiedAt.toISOString())
+            : response("resource.found", resource);
+    });
+}
+
+export { makeRouteFolder };

package/dist/plugins/static/plugin.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var serverUtils = require('@duplojs/server-utils');
+var kind = require('./kind.cjs');
+var makeRouteFile = require('./makeRouteFile.cjs');
+var makeRouteFolder = require('./makeRouteFolder.cjs');
+
+class StaticPluginError extends utils.kindHeritage("static-plugin", kind.createStaticPluginKind("static-plugin"), Error) {
+    information;
+    error;
+    constructor(information, error) {
+        super({}, [`Error during registration static route: ${information}`]);
+        this.information = information;
+        this.error = error;
+    }
+}
+function staticPlugin(...args) {
+    const route = utils.P.match(args)
+        .with([utils.toCurriedPredicate(serverUtils.SF.isFolderInterface)], ([source, params]) => makeRouteFolder.makeRouteFolder({
+        source,
+        ...params,
+    }))
+        .with([utils.toCurriedPredicate(serverUtils.SF.isFileInterface)], ([source, params]) => makeRouteFile.makeRouteFile({
+        source,
+        ...params,
+    }))
+        .exhaustive();
+    return {
+        name: "static",
+        routes: [route],
+        hooksHubLifeCycle: [
+            {
+                beforeStartServer: async () => {
+                    const statResult = await args[0].stat();
+                    if (utils.E.isLeft(statResult)) {
+                        throw new StaticPluginError(`source does not exit (${args[0].path}).`, utils.unwrap(statResult));
+                    }
+                    const stat = utils.unwrap(statResult);
+                    if (serverUtils.SF.isFileInterface(args[0]) && !stat.isFile) {
+                        throw new StaticPluginError(`source does not file (${args[0].path}).`, stat);
+                    }
+                    else if (serverUtils.SF.isFolderInterface(args[0]) && stat.isFile) {
+                        throw new StaticPluginError(`source does not folder (${args[0].path}).`, stat);
+                    }
+                },
+            },
+        ],
+    };
+}
+
+exports.StaticPluginError = StaticPluginError;
+exports.staticPlugin = staticPlugin;

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

@@ -0,0 +1,26 @@
+import { type AnyTuple } from "@duplojs/utils";
+import { SF } from "@duplojs/server-utils";
+import type { HubPlugin } from "../../core/hub";
+import type { RoutePath } from "../../core/route";
+import { type CacheControlDirectives } from "../cacheController/types";
+export interface BaseStaticPluginParams {
+    readonly cacheControlConfig?: CacheControlDirectives;
+}
+export interface StaticPluginFileParams extends BaseStaticPluginParams {
+    readonly path: RoutePath | AnyTuple<RoutePath>;
+}
+export interface StaticPluginFolderParams extends BaseStaticPluginParams {
+    readonly prefix: RoutePath | AnyTuple<RoutePath>;
+    readonly directoryIndexFilePrefix?: string;
+}
+declare const StaticPluginError_base: new (params: {
+    "@DuplojsStaticPlugin/static-plugin"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsStaticPlugin/static-plugin", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"static-plugin", unknown>, unknown>;
+export declare class StaticPluginError extends StaticPluginError_base {
+    information: string;
+    error: unknown;
+    constructor(information: string, error: unknown);
+}
+export declare function staticPlugin(source: SF.FolderInterface, params: StaticPluginFolderParams): HubPlugin;
+export declare function staticPlugin(source: SF.FileInterface, params: StaticPluginFileParams): HubPlugin;
+export {};

package/dist/plugins/static/plugin.mjs

@@ -0,0 +1,50 @@
+import { kindHeritage, P, toCurriedPredicate, E, unwrap } from '@duplojs/utils';
+import { SF } from '@duplojs/server-utils';
+import { createStaticPluginKind } from './kind.mjs';
+import { makeRouteFile } from './makeRouteFile.mjs';
+import { makeRouteFolder } from './makeRouteFolder.mjs';
+
+class StaticPluginError extends kindHeritage("static-plugin", createStaticPluginKind("static-plugin"), Error) {
+    information;
+    error;
+    constructor(information, error) {
+        super({}, [`Error during registration static route: ${information}`]);
+        this.information = information;
+        this.error = error;
+    }
+}
+function staticPlugin(...args) {
+    const route = P.match(args)
+        .with([toCurriedPredicate(SF.isFolderInterface)], ([source, params]) => makeRouteFolder({
+        source,
+        ...params,
+    }))
+        .with([toCurriedPredicate(SF.isFileInterface)], ([source, params]) => makeRouteFile({
+        source,
+        ...params,
+    }))
+        .exhaustive();
+    return {
+        name: "static",
+        routes: [route],
+        hooksHubLifeCycle: [
+            {
+                beforeStartServer: async () => {
+                    const statResult = await args[0].stat();
+                    if (E.isLeft(statResult)) {
+                        throw new StaticPluginError(`source does not exit (${args[0].path}).`, unwrap(statResult));
+                    }
+                    const stat = unwrap(statResult);
+                    if (SF.isFileInterface(args[0]) && !stat.isFile) {
+                        throw new StaticPluginError(`source does not file (${args[0].path}).`, stat);
+                    }
+                    else if (SF.isFolderInterface(args[0]) && stat.isFile) {
+                        throw new StaticPluginError(`source does not folder (${args[0].path}).`, stat);
+                    }
+                },
+            },
+        ],
+    };
+}
+
+export { StaticPluginError, staticPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.7.4",
+  "version": "0.8.5",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -17,9 +17,9 @@
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types && npm -w docs run test:types",
-    "test:lint": "eslint --quiet",
-    "test:lint:fix": "eslint --fix --quiet",
+    "test:types": "./.commands/test-types.sh",
+    "test:lint": "./.commands/test-eslint.sh",
+    "test:lint:fix": "./.commands/test-eslint.sh --fix",
     "prepare": "husky"
   },
   "types": "./dist/core/index.d.ts",
@@ -58,6 +58,16 @@
       "import": "./dist/plugins/openApiGenerator/index.mjs",
       "require": "./dist/plugins/openApiGenerator/index.cjs",
       "types": "./dist/plugins/openApiGenerator/index.d.ts"
+    },
+    "./cacheController": {
+       "import": "./dist/plugins/cacheController/index.mjs",
+      "require": "./dist/plugins/cacheController/index.cjs",
+      "types": "./dist/plugins/cacheController/index.d.ts"
+    },
+    "./static": {
+      "import": "./dist/plugins/static/index.mjs",
+      "require": "./dist/plugins/static/index.cjs",
+      "types": "./dist/plugins/static/index.d.ts"
     }
   },
   "files": [
@@ -65,9 +75,9 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@duplojs/data-parser-tools": ">=0.2.8 <1.0.0",
-    "@duplojs/server-utils": ">=0.2.0 <1.0.0",
-    "@duplojs/utils": ">=1.5.8 <2.0.0"
+    "@duplojs/data-parser-tools": ">=0.2.9 <1.0.0",
+    "@duplojs/server-utils": ">=0.2.2 <1.0.0",
+    "@duplojs/utils": ">=1.5.13 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -80,6 +90,7 @@
     "@types/web": "^0.0.317",
     "@vitest/coverage-istanbul": "3.2.4",
     "eslint": "9.34.0",
+    "eventsource": "^4.1.0",
     "form-data": "^4.0.5",
     "husky": "9.1.7",
     "node-mocks-http": "^1.17.2",