@duplojs/http 0.7.0 → 0.7.4

package/dist/client/queryToString.cjs

@@ -11,11 +11,11 @@ function queryToString(query) {
         }
         if (value instanceof Array) {
             value.forEach((subValue) => {
-                pv.push(`${key}=${subValue}`);
+                pv.push(`${key}=${subValue.toString()}`);
             });
         }
         else {
-            pv.push(`${key}=${value}`);
+            pv.push(`${key}=${value.toString()}`);
         }
         return pv;
     }, [])

package/dist/client/queryToString.mjs

@@ -9,11 +9,11 @@ function queryToString(query) {
         }
         if (value instanceof Array) {
             value.forEach((subValue) => {
-                pv.push(`${key}=${subValue}`);
+                pv.push(`${key}=${subValue.toString()}`);
             });
         }
         else {
-            pv.push(`${key}=${value}`);
+            pv.push(`${key}=${value.toString()}`);
         }
         return pv;
     }, [])

package/dist/client/types/clientRequestParams.d.ts

@@ -4,9 +4,15 @@ import { type ObjectCanBeEmpty } from "./ObjectCanBeEmpty";
 import type * as OO from "@duplojs/utils/object";
 export interface ClientRequestInitParams extends Pick<RequestInit, "cache" | "credentials" | "integrity" | "keepalive" | "mode" | "redirect" | "referrer" | "referrerPolicy" | "signal"> {
 }
-export type ClientRequestParamsHeaders = Record<string, string | undefined>;
-export type ClientRequestParamsParams = Record<string, string | undefined>;
-export type ClientRequestParamsQuery = Record<string, MaybeArray<string> | undefined>;
+export type ClientRequestParamsHeaders = Record<string, string | undefined | {
+    toString(): string;
+}>;
+export type ClientRequestParamsParams = Record<string, string | undefined | {
+    toString(): string;
+}>;
+export type ClientRequestParamsQuery = Record<string, MaybeArray<string | {
+    toString(): string;
+}> | undefined>;
 export type ClientRequestParamsBody = unknown;
 export interface ClientRequestParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
     method: string;

package/dist/client/types/serverRoute.d.ts

@@ -1,9 +1,15 @@
 import { type SimplifyTopLevel, type MaybeArray, type IsEqual } from "@duplojs/utils";
 import type * as SS from "@duplojs/utils/string";
 export type ServerPrimitiveData = string | undefined | number | null | boolean;
-export type ServerRouteHeaders = Record<string, ServerPrimitiveData>;
-export type ServerRouteParams = Record<string, ServerPrimitiveData>;
-export type ServerRouteQuery = Record<string, MaybeArray<ServerPrimitiveData>>;
+export type ServerRouteHeaders = Record<string, ServerPrimitiveData | {
+    toString(): string;
+}>;
+export type ServerRouteParams = Record<string, ServerPrimitiveData | {
+    toString(): string;
+}>;
+export type ServerRouteQuery = Record<string, MaybeArray<ServerPrimitiveData | {
+    toString(): string;
+}>>;
 export type ServerRouteBody = unknown;
 export type ServerRouteResponseBody = unknown;
 export interface ServerRouteResponse {

package/dist/core/clean/entity.cjs

@@ -1,33 +1,24 @@
 'use strict';
 
 var utils = require('@duplojs/utils');
-var clean = require('@duplojs/utils/clean');
+require('@duplojs/utils/clean');
 
-function propertiesDefinitionToSchema(definition, method) {
-    return utils.pipe(definition, utils.P.when(clean.newTypeHandlerKind.has, (value) => value[method]()), utils.P.when(utils.isType("array"), utils.innerPipe(utils.A.map((element) => element[method]()), (options) => {
-        utils.asserts(options, utils.A.minElements(1));
-        return utils.DP.union(options);
-    })), utils.P.otherwise((definition) => utils.pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
-        if (definition.inArray) {
-            return utils.pipe(dataParser, utils.DP.array, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.min === "number"
-                ? dataParser.addChecker(utils.DP.checkerArrayMin(definition.inArray.min))
-                : dataParser, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.max === "number"
-                ? dataParser.addChecker(utils.DP.checkerArrayMax(definition.inArray.max))
-                : dataParser);
-        }
-        return dataParser;
-    }, (dataParser) => definition.nullable === true
-        ? utils.DP.nullable(dataParser)
-        : dataParser)));
-}
-clean.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), utils.O.fromEntries, utils.DPE.object));
-clean.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
-    ? {
-        ...shape,
-        _entityName: typeof params.addEntityName === "string"
-            ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
-            : utils.DP.literal(self.name),
+utils.C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
+    if (typeof keys === "string") {
+        return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
+    }
+    return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), utils.O.fromEntries, utils.DPE.object);
+});
+utils.C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
+    if (typeof keys === "string") {
+        return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
     }
-    : shape, utils.DPE.object));
+    return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+        ? {
+            ...shape,
+            _entityName: typeof params.addEntityName === "string"
+                ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
+                : utils.DP.literal(self.name),
+        }
+        : shape, utils.DPE.object);
+});

package/dist/core/clean/entity.d.ts

@@ -1,20 +1,20 @@
-import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends } from "@duplojs/utils";
-import { type EntityRawProperties, type EntityProperties, type EntityPropertiesDefinition } from "@duplojs/utils/clean";
+import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends, C, type MaybeArray } from "@duplojs/utils";
+import "@duplojs/utils/clean";
 interface ToEndpointSchemaParams {
     addEntityName?: boolean | string;
 }
 declare module "@duplojs/utils/clean" {
-    interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> {
-        toExtractParser<GenericEntityProperties extends EntityProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityProperties = keyof GenericEntityProperties>(keys?: GenericKey[]): ReturnType<typeof DPE.object<{
-            [Prop in GenericKey]: DP.Contract<GenericEntityProperties[Prop], unknown>;
-        }>>;
-        toEndpointSchema<GenericEntityRawProperties extends EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityRawProperties = keyof GenericEntityRawProperties, const GenericParams extends ToEndpointSchemaParams = {}>(keys?: GenericKey[], params?: GenericParams | ToEndpointSchemaParams): ReturnType<typeof DPE.object<SimplifyTopLevel<{
-            [Prop in GenericKey]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
+    interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends C.EntityPropertiesDefinition = C.EntityPropertiesDefinition> {
+        toExtractParser<GenericEntityProperties extends C.EntityProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityProperties> = readonly (keyof GenericEntityProperties)[]>(keys?: GenericKey): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
+            [Prop in GenericKey[number]]: DP.Contract<GenericEntityProperties[Prop], unknown>;
+        }>>> : DP.Contract<GenericEntityProperties[Extract<GenericKey, string>], unknown>;
+        toEndpointSchema<GenericEntityRawProperties extends C.EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityRawProperties> = readonly (keyof GenericEntityRawProperties)[], const GenericParams extends (ToEndpointSchemaParams) = {}>(keys?: GenericKey, params?: (GenericParams | ToEndpointSchemaParams) & (GenericKey extends string ? never : unknown)): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
+            [Prop in GenericKey[number]]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
         } & (IsEqual<GenericParams["addEntityName"], true> extends true ? {
             [Prop in "_entityName"]: DP.Contract<GenericName, unknown>;
         } : {}) & (IsExtends<GenericParams["addEntityName"], string> extends true ? {
             [Prop in "_entityName"]: DP.Contract<`${GenericName}/${GenericParams["addEntityName"]}`, unknown>;
-        } : {})>>>;
+        } : {})>>> : DP.Contract<GenericEntityRawProperties[Extract<GenericKey, string>], unknown>;
     }
 }
 export {};

package/dist/core/clean/entity.mjs

@@ -1,31 +1,22 @@
-import { pipe, P, isType, innerPipe, A, asserts, DP, O, DPE } from '@duplojs/utils';
-import { newTypeHandlerKind, createEntity } from '@duplojs/utils/clean';
+import { C, pipe, O, A, DPE, DP } from '@duplojs/utils';
+import '@duplojs/utils/clean';
 
-function propertiesDefinitionToSchema(definition, method) {
-    return pipe(definition, P.when(newTypeHandlerKind.has, (value) => value[method]()), P.when(isType("array"), innerPipe(A.map((element) => element[method]()), (options) => {
-        asserts(options, A.minElements(1));
-        return DP.union(options);
-    })), P.otherwise((definition) => pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
-        if (definition.inArray) {
-            return pipe(dataParser, DP.array, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.min === "number"
-                ? dataParser.addChecker(DP.checkerArrayMin(definition.inArray.min))
-                : dataParser, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.max === "number"
-                ? dataParser.addChecker(DP.checkerArrayMax(definition.inArray.max))
-                : dataParser);
-        }
-        return dataParser;
-    }, (dataParser) => definition.nullable === true
-        ? DP.nullable(dataParser)
-        : dataParser)));
-}
-createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), O.fromEntries, DPE.object));
-createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
-    ? {
-        ...shape,
-        _entityName: typeof params.addEntityName === "string"
-            ? DP.literal(`${self.name}/${params.addEntityName}`)
-            : DP.literal(self.name),
+C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
+    if (typeof keys === "string") {
+        return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
+    }
+    return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), O.fromEntries, DPE.object);
+});
+C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
+    if (typeof keys === "string") {
+        return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
     }
-    : shape, DPE.object));
+    return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+        ? {
+            ...shape,
+            _entityName: typeof params.addEntityName === "string"
+                ? DP.literal(`${self.name}/${params.addEntityName}`)
+                : DP.literal(self.name),
+        }
+        : shape, DPE.object);
+});

package/dist/plugins/codeGenerator/plugin.cjs

@@ -43,8 +43,11 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript__namespace.render(utils.DP.union(dataParserRoutes), {
                         identifier: "Routes",
+                        mode: "in",
                         transformers: [
                             typescriptTransfomer.fileTransformer,
+                            typescriptTransfomer.dateTransformer,
+                            typescriptTransfomer.timeTransformer,
                             ...DataParserToTypescript__namespace.defaultTransformers,
                         ],
                     });

package/dist/plugins/codeGenerator/plugin.mjs

@@ -2,7 +2,7 @@ import * as DataParserToTypescript from '@duplojs/data-parser-tools/toTypescript
 import { equal, A, DP, asserts, E } from '@duplojs/utils';
 import { routeToDataParser } from './routeToDataParser.mjs';
 import { SF } from '@duplojs/server-utils';
-import { fileTransformer } from './typescriptTransfomer.mjs';
+import { fileTransformer, dateTransformer, timeTransformer } from './typescriptTransfomer.mjs';
 
 function codeGeneratorPlugin(pluginParams) {
     return () => ({
@@ -22,8 +22,11 @@ function codeGeneratorPlugin(pluginParams) {
                     }
                     const output = DataParserToTypescript.render(DP.union(dataParserRoutes), {
                         identifier: "Routes",
+                        mode: "in",
                         transformers: [
                             fileTransformer,
+                            dateTransformer,
+                            timeTransformer,
                             ...DataParserToTypescript.defaultTransformers,
                         ],
                     });

package/dist/plugins/codeGenerator/typescriptTransfomer.cjs

@@ -2,8 +2,27 @@
 
 var DataParserToTypescript = require('@duplojs/data-parser-tools/toTypescript');
 var serverUtils = require('@duplojs/server-utils');
+var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 
 const fileTransformer = DataParserToTypescript.createTransformer(serverUtils.SDP.fileKind.has, (__, { success }) => success(typescript.factory.createTypeReferenceNode("File")));
+const dateTransformer = DataParserToTypescript.createTransformer(utils.DP.dateKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    addImport("@duplojs/utils/date", "SerializedTheDate");
+    return success(typescript.factory.createUnionTypeNode([
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheDate")),
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheDate")),
+    ]));
+});
+const timeTransformer = DataParserToTypescript.createTransformer(utils.DP.timeKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    addImport("@duplojs/utils/date", "SerializedTheTime");
+    return success(typescript.factory.createUnionTypeNode([
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheTime")),
+        typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheTime")),
+    ]));
+});
 
+exports.dateTransformer = dateTransformer;
 exports.fileTransformer = fileTransformer;
+exports.timeTransformer = timeTransformer;

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

@@ -1 +1,4 @@
-export declare const fileTransformer: (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const fileTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;
+export declare const dateTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;
+export declare const timeTransformer: (schema: DP.DataParsers, params: import("@duplojs/data-parser-tools/toTypescript").TransformerParams) => import("@duplojs/data-parser-tools/toTypescript").MaybeTransformerEither;

package/dist/plugins/codeGenerator/typescriptTransfomer.mjs

@@ -1,7 +1,24 @@
 import { createTransformer } from '@duplojs/data-parser-tools/toTypescript';
 import { SDP } from '@duplojs/server-utils';
+import { DP } from '@duplojs/utils';
 import { factory } from 'typescript';
 
 const fileTransformer = createTransformer(SDP.fileKind.has, (__, { success }) => success(factory.createTypeReferenceNode("File")));
+const dateTransformer = createTransformer(DP.dateKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    addImport("@duplojs/utils/date", "SerializedTheDate");
+    return success(factory.createUnionTypeNode([
+        factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheDate")),
+        factory.createTypeReferenceNode(factory.createIdentifier("TheDate")),
+    ]));
+});
+const timeTransformer = createTransformer(DP.timeKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    addImport("@duplojs/utils/date", "SerializedTheTime");
+    return success(factory.createUnionTypeNode([
+        factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheTime")),
+        factory.createTypeReferenceNode(factory.createIdentifier("TheTime")),
+    ]));
+});
 
-export { fileTransformer };
+export { dateTransformer, fileTransformer, timeTransformer };

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -12,7 +12,7 @@ function factoryJsonSchema(params) {
         ?? `NotIdentified${params.resultSchemaContext.size}`;
     const renderResult = toJsonSchema.render(params.schema, {
         identifier,
-        mode: params.mode,
+        mode: "in",
         context: params.context,
         version: "openApi31",
         transformers: toJsonSchema.defaultTransformers,
@@ -57,7 +57,6 @@ function routeToOpenApi(route, params) {
         schema: factoryJsonSchema({
             context: params.contextToJsonSchemaFactory,
             resultSchemaContext: params.resultSchemaContext,
-            mode: "in",
             schema,
         }),
     }))));
@@ -68,7 +67,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -80,7 +78,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -92,7 +89,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: primitiveSchema,
                 }),
             },
@@ -103,7 +99,6 @@ function routeToOpenApi(route, params) {
             ? factoryJsonSchema({
                 context: params.contextToJsonSchemaFactory,
                 resultSchemaContext: params.resultSchemaContext,
-                mode: "in",
                 schema: body,
             })
             : undefined;

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -10,7 +10,7 @@ function factoryJsonSchema(params) {
         ?? `NotIdentified${params.resultSchemaContext.size}`;
     const renderResult = render(params.schema, {
         identifier,
-        mode: params.mode,
+        mode: "in",
         context: params.context,
         version: "openApi31",
         transformers: defaultTransformers,
@@ -55,7 +55,6 @@ function routeToOpenApi(route, params) {
         schema: factoryJsonSchema({
             context: params.contextToJsonSchemaFactory,
             resultSchemaContext: params.resultSchemaContext,
-            mode: "in",
             schema,
         }),
     }))));
@@ -66,7 +65,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -78,7 +76,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -90,7 +87,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: primitiveSchema,
                 }),
             },
@@ -101,7 +97,6 @@ function routeToOpenApi(route, params) {
             ? factoryJsonSchema({
                 context: params.contextToJsonSchemaFactory,
                 resultSchemaContext: params.resultSchemaContext,
-                mode: "in",
                 schema: body,
             })
             : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.7.0",
+  "version": "0.7.4",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -65,9 +65,9 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@duplojs/data-parser-tools": ">=0.2.7 <1.0.0",
+    "@duplojs/data-parser-tools": ">=0.2.8 <1.0.0",
     "@duplojs/server-utils": ">=0.2.0 <1.0.0",
-    "@duplojs/utils": ">=1.5.4 <2.0.0"
+    "@duplojs/utils": ">=1.5.8 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",