@duplojs/http 0.5.1 → 0.6.1

package/dist/client/httpClient.cjs

@@ -140,6 +140,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/httpClient.d.ts

@@ -45,6 +45,7 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     get: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "GET">;
     post: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "POST">;
     put: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PUT">;
+    patch: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PATCH">;
     delete: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "DELETE">;
 }
 export interface CreateHttpClientParams {

package/dist/client/httpClient.mjs

@@ -118,6 +118,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/queryToString.cjs

@@ -9,7 +9,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/queryToString.mjs

@@ -7,7 +7,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/unexpectedResponseError.d.ts

@@ -6,7 +6,7 @@ export interface RequestErrorContent {
 }
 declare const UnexpectedInformationResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-information-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
 export declare class UnexpectedInformationResponseError extends UnexpectedInformationResponseError_base {
     information: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -14,7 +14,7 @@ export declare class UnexpectedInformationResponseError extends UnexpectedInform
 }
 declare const UnexpectedCodeResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-code-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
 export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseError_base {
     code: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -22,7 +22,7 @@ export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseE
 }
 declare const UnexpectedResponseTypeError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-type-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
 export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeError_base {
     expectType: "informational" | "successful" | "redirection" | "clientError" | "serverError";
     response: RequestErrorContent | ClientResponse;
@@ -30,7 +30,7 @@ export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeE
 }
 declare const UnexpectedResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
 export declare class UnexpectedResponseError extends UnexpectedResponseError_base {
     response: RequestErrorContent | ClientResponse;
     constructor(response: RequestErrorContent | ClientResponse);

package/dist/core/builders/preflight/route.d.ts

@@ -15,12 +15,12 @@ declare module "./builder" {
             readonly preflightSteps: GenericDefinition["preflightSteps"];
             readonly steps: readonly [];
             readonly hooks: readonly [
-                ...GenericDefinition["hooks"],
-                ...GenericHooks
+                ...GenericHooks,
+                ...GenericDefinition["hooks"]
             ];
             readonly metadata: readonly [
-                ...GenericDefinition["metadata"],
-                ...GenericMetadata
+                ...GenericMetadata,
+                ...GenericDefinition["metadata"]
             ];
         }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
     }

package/dist/core/response/contract.d.ts

@@ -283,7 +283,7 @@ export declare namespace ResponseContract {
     }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
-    }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
+    }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
     export class Error extends Error_base {
         information: string;
         dataParserError?: DP.DataParserError | undefined;

package/dist/core/response/hook.d.ts

@@ -2,7 +2,7 @@ import { type ResponseCode, Response } from "../response";
 import { type HookRouteLifeCycle } from "../route/hooks";
 declare const HookResponse_base: new (params: {
     "@DuplojsHttpCore/hook-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
 export declare class HookResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends HookResponse_base {
     code: GenericCode;
     information: GenericInformation;

package/dist/core/response/predicted.d.ts

@@ -1,7 +1,7 @@
 import { type ResponseCode, Response } from "../response";
 declare const PredictedResponse_base: new (params: {
     "@DuplojsHttpCore/predicted-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
 export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
     code: GenericCode;
     information: GenericInformation;

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

@@ -2,7 +2,7 @@ import { type Route } from "../route";
 import { type Steps } from "../steps";
 declare const RouterBuildError_base: new (params: {
     "@DuplojsHttpCore/router-build-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
 export declare class RouterBuildError extends RouterBuildError_base {
     route: Route;
     element: Route | Steps;

package/dist/interfaces/node/createHttpServer.cjs

@@ -51,6 +51,9 @@ function createHttpServer(inputHub, params) {
                 response: serverResponse,
             },
         }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
         return new Promise((resolve) => {
             server.listen({
                 port: httpServerParams.port,

package/dist/interfaces/node/createHttpServer.mjs

@@ -49,6 +49,9 @@ function createHttpServer(inputHub, params) {
                 response: serverResponse,
             },
         }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
         return new Promise((resolve) => {
             server.listen({
                 port: httpServerParams.port,

package/dist/interfaces/node/error/bodyParseUnknownError.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseUnknownError_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-unknown-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
 export declare class BodyParseUnknownError extends BodyParseUnknownError_base {
     contentType: string;
     unknownError: unknown;

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseWrongChunkReceived_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
 export declare class BodyParseWrongChunkReceived extends BodyParseWrongChunkReceived_base {
     wrongChunk: unknown;
     constructor(wrongChunk: unknown);

package/dist/interfaces/node/error/bodySizeExceedsLimitError.d.ts

@@ -1,7 +1,7 @@
 import { type BytesInString } from "@duplojs/utils";
 declare const BodySizeExceedsLimitError_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
 export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
     bytesInString: BytesInString | number;
     constructor(bytesInString: BytesInString | number);

package/dist/plugins/openApiGenerator/makeOpenApiRoute.cjs

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

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

@@ -3,7 +3,7 @@ import type { RoutePath } from "../../core/route";
 import { DP } from "@duplojs/utils";
 export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
     readonly method: "GET";
-    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
+    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>, import("../../core/metadata").Metadata<"ignore-by-open-api-generator", unknown>, import("../../core/metadata").Metadata<"ignore-by-code-generator", unknown>];
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];

package/dist/plugins/openApiGenerator/makeOpenApiRoute.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -10,16 +10,19 @@
   },
   "scripts": {
     "build": "rollup --config",
+    "docs:dev": "npm -w docs run docs:dev",
+    "docs:build": "npm -w docs run docs:build",
+    "docs:preview": "npm -w docs run docs:preview",
     "test:tu": "vitest --coverage",
     "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",
-    "test:lint": "eslint",
-    "test:lint:fix": "eslint --fix",
+    "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",
     "prepare": "husky"
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/core/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/core/index.mjs",
@@ -63,7 +66,7 @@
   ],
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
-    "@duplojs/utils": ">=1.4.40 <2.0.0"
+    "@duplojs/utils": ">=1.4.46 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -89,7 +92,8 @@
     "vitest": "3.2.4"
   },
   "workspaces": [
-    "integration"
+    "integration",
+    "docs"
   ],
   "keywords": [],
   "engines": {