@duplojs/data-parser-tools 0.2.6 → 0.2.7

package/dist/index.cjs

@@ -2,8 +2,11 @@
 
 var index = require('./toTypescript/index.cjs');
 var index$1 = require('./toJsonSchema/index.cjs');
+require('./utils/index.cjs');
+var getRecursiveDataParser = require('./utils/getRecursiveDataParser.cjs');
 
 
 
 exports.DataParserToTypescript = index;
 exports.DataParserToJsonSchema = index$1;
+exports.getRecursiveDataParser = getRecursiveDataParser.getRecursiveDataParser;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * as DataParserToTypescript from "./toTypescript";
 export * as DataParserToJsonSchema from "./toJsonSchema";
+export * from "./utils";

package/dist/index.mjs

@@ -2,3 +2,5 @@ import * as index from './toTypescript/index.mjs';
 export { index as DataParserToTypescript };
 import * as index$1 from './toJsonSchema/index.mjs';
 export { index$1 as DataParserToJsonSchema };
+import './utils/index.mjs';
+export { getRecursiveDataParser } from './utils/getRecursiveDataParser.mjs';

package/dist/toJsonSchema/override.cjs

@@ -11,17 +11,19 @@ dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, id
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchema", (schema, overrideJsonSchema) => {
-    schema.definition.overrideJsonSchema = "schema" in overrideJsonSchema
-        ? {
-            in: overrideJsonSchema,
-            out: overrideJsonSchema,
-        }
-        : overrideJsonSchema;
+dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer.schema, overrideTransformer.isOptional);
+    }
+    else {
+        schema.definition.overrideJsonSchemaTransformer = undefined;
+    }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideJsonSchema", (schema, overrideJsonSchema) => {
+dataParser.dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideJsonSchema(overrideJsonSchema);
+    newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;
 });

package/dist/toJsonSchema/override.d.ts

@@ -1,5 +1,4 @@
-import { type TransformerMode, type TransformerSuccess } from "./transformer/create";
-export type OverrideJsonSchemaDataParser = Partial<Record<TransformerMode, TransformerSuccess>>;
+import { type TransformerBuildFunction, type TransformerSuccess } from "./transformer/create";
 declare module "@duplojs/utils/dataParser" {
     interface DataParser {
         /**
@@ -8,13 +7,13 @@ declare module "@duplojs/utils/dataParser" {
         setIdentifier(input: string): this;
         addIdentifier(input: string): this;
         /**
-         * @deprecated this method mutated the dataParser by adding an override json schema
+         * @deprecated this method mutated the dataParser by adding an override transformer
          */
-        setOverrideJsonSchema(schema: TransformerSuccess | OverrideJsonSchemaDataParser): this;
-        addOverrideJsonSchema(schema: TransformerSuccess | OverrideJsonSchemaDataParser): this;
+        setOverrideJsonSchemaTransformer(transformer: TransformerSuccess | TransformerBuildFunction<this> | null): this;
+        addOverrideJsonSchemaTransformer(transformer: TransformerSuccess | TransformerBuildFunction<this> | null): this;
     }
     interface DataParserDefinition {
         identifier?: string;
-        overrideJsonSchema?: OverrideJsonSchemaDataParser;
+        overrideJsonSchemaTransformer?: TransformerBuildFunction;
     }
 }

package/dist/toJsonSchema/override.mjs

@@ -9,17 +9,19 @@ dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) =
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideJsonSchema", (schema, overrideJsonSchema) => {
-    schema.definition.overrideJsonSchema = "schema" in overrideJsonSchema
-        ? {
-            in: overrideJsonSchema,
-            out: overrideJsonSchema,
-        }
-        : overrideJsonSchema;
+dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer.schema, overrideTransformer.isOptional);
+    }
+    else {
+        schema.definition.overrideJsonSchemaTransformer = undefined;
+    }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideJsonSchema", (schema, overrideJsonSchema) => {
+dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideJsonSchema(overrideJsonSchema);
+    newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;
 });

package/dist/toJsonSchema/render.cjs

@@ -3,8 +3,9 @@
 var utils = require('@duplojs/utils');
 require('./transformer/index.cjs');
 var kind = require('./kind.cjs');
-var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+require('../utils/index.cjs');
 var transformer = require('./transformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
 var create = require('./transformer/create.cjs');
 
 class DataParserToJsonSchemaRenderError extends utils.kindHeritage("data-parser-to-json-schema-render-error", kind.createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {

package/dist/toJsonSchema/render.mjs

@@ -1,8 +1,9 @@
 import { kindHeritage, E, unwrap, G } from '@duplojs/utils';
 import './transformer/index.mjs';
 import { createToJsonSchemaKind } from './kind.mjs';
-import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import '../utils/index.mjs';
 import { transformer, buildRef } from './transformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
 import { supportedVersions } from './transformer/create.mjs';
 
 class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-json-schema-render-error", createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {

package/dist/toJsonSchema/transformer/create.d.ts

@@ -41,4 +41,5 @@ export interface TransformerParams {
     success(result: JsonSchema, isOptional?: boolean): TransformerSuccessEither;
     buildError(): DataParserErrorEither;
 }
-export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;
+export type TransformerBuildFunction<GenericDataParser extends DP.DataParsers = DP.DataParsers> = (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: TransformerBuildFunction<GenericDataParser>): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -13,9 +13,6 @@ function buildRef(name, version) {
     return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
-    if (schema.definition.overrideJsonSchema?.[params.mode]) {
-        return utils.E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
-    }
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -64,16 +61,18 @@ function transformer(schema, params) {
             return utils.E.left("buildDataParserError", currentSchema);
         },
     };
-    const result = utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (utils.E.isLeft(result)) {
-            if (utils.unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideJsonSchemaTransformer
+        ? currentSchema.definition.overrideJsonSchemaTransformer(currentSchema.addOverrideJsonSchemaTransformer(null), functionParams)
+        : utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (utils.E.isLeft(result)) {
+                if (utils.unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (utils.E.isLeft(result)) {
         return result;
     }

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,4 +1,4 @@
-import { E, A, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
 
 function buildRef(name, version) {
     if (version === "openApi3"
@@ -11,9 +11,6 @@ function buildRef(name, version) {
     return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
-    if (schema.definition.overrideJsonSchema?.[params.mode]) {
-        return E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
-    }
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -62,16 +59,18 @@ function transformer(schema, params) {
             return E.left("buildDataParserError", currentSchema);
         },
     };
-    const result = A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (E.isLeft(result)) {
-            if (unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideJsonSchemaTransformer
+        ? currentSchema.definition.overrideJsonSchemaTransformer(currentSchema.addOverrideJsonSchemaTransformer(null), functionParams)
+        : A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (E.isLeft(result)) {
+                if (unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (E.isLeft(result)) {
         return result;
     }

package/dist/toTypescript/override.cjs

@@ -11,17 +11,19 @@ dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, id
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
-    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
-        ? {
-            in: overrideTypeNode,
-            out: overrideTypeNode,
-        }
-        : overrideTypeNode;
+dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideTypescriptTransformer = undefined;
+    }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideTypeNode(overrideTypeNode);
+    newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;
 });

package/dist/toTypescript/override.d.ts

@@ -1,6 +1,5 @@
 import { type TypeNode } from "typescript";
-import { type TransformerMode } from "./transformer";
-export type OverrideTypeNodeDataParser = Partial<Record<TransformerMode, TypeNode>>;
+import { type TransformerBuildFunction } from "./transformer";
 declare module "@duplojs/utils/dataParser" {
     interface DataParser {
         /**
@@ -9,13 +8,13 @@ declare module "@duplojs/utils/dataParser" {
         setIdentifier(input: string): this;
         addIdentifier(input: string): this;
         /**
-         * @deprecated this method mutated the dataParser by adding an override type node
+         * @deprecated this method mutated the dataParser by adding an override transformer
          */
-        setOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
-        addOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
+        setOverrideTypescriptTransformer(typeNode: TypeNode | TransformerBuildFunction<this> | null): this;
+        addOverrideTypescriptTransformer(typeNode: TypeNode | TransformerBuildFunction<this> | null): this;
     }
     interface DataParserDefinition {
         identifier?: string;
-        overrideTypeNode?: OverrideTypeNodeDataParser;
+        overrideTypescriptTransformer?: TransformerBuildFunction;
     }
 }

package/dist/toTypescript/override.mjs

@@ -9,17 +9,19 @@ dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) =
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
-    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
-        ? {
-            in: overrideTypeNode,
-            out: overrideTypeNode,
-        }
-        : overrideTypeNode;
+dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideTypescriptTransformer = undefined;
+    }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideTypeNode(overrideTypeNode);
+    newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;
 });

package/dist/toTypescript/render.cjs

@@ -4,9 +4,10 @@ var utils = require('@duplojs/utils');
 require('./transformer/index.cjs');
 var typescript = require('typescript');
 var kind = require('./kind.cjs');
-var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+require('../utils/index.cjs');
 var importTypesTransformer = require('./transformer/importTypesTransformer.cjs');
 var transformer = require('./transformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
 
 class DataParserToTypescriptRenderError extends utils.kindHeritage("data-parser-to-typescript-render-error", kind.createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;

package/dist/toTypescript/render.d.ts

@@ -1,4 +1,5 @@
-import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type SupportedDataParsers, type MapImportType } from "./transformer";
+import { DP } from "@duplojs/utils";
+import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type MapImportType } from "./transformer";
 export interface RenderParams {
     readonly identifier: string;
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
@@ -11,9 +12,9 @@ declare const DataParserToTypescriptRenderError_base: new (params: {
     "@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error"?: unknown;
 }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"data-parser-to-typescript-render-error", unknown>, unknown> & Error;
 export declare class DataParserToTypescriptRenderError extends DataParserToTypescriptRenderError_base {
-    schema: SupportedDataParsers;
+    schema: DP.DataParser;
     error: DataParserNotSupportedEither | DataParserErrorEither;
-    constructor(schema: SupportedDataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
+    constructor(schema: DP.DataParser, error: DataParserNotSupportedEither | DataParserErrorEither);
 }
-export declare function render(schema: SupportedDataParsers, params: RenderParams): string;
+export declare function render(schema: DP.DataParser, params: RenderParams): string;
 export {};

package/dist/toTypescript/render.mjs

@@ -2,9 +2,10 @@ import { kindHeritage, E, DP, unwrap, pipe, G, A, S } from '@duplojs/utils';
 import './transformer/index.mjs';
 import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
 import { createToTypescriptKind } from './kind.mjs';
-import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import '../utils/index.mjs';
 import { importTypesTransformer } from './transformer/importTypesTransformer.mjs';
 import { transformer } from './transformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
 
 class DataParserToTypescriptRenderError extends kindHeritage("data-parser-to-typescript-render-error", createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;

package/dist/toTypescript/transformer/create.d.ts

@@ -1,11 +1,9 @@
 import { type TypeAliasDeclaration, type TypeNode } from "typescript";
 import { type DP, E } from "@duplojs/utils";
-import { type SDP } from "@duplojs/server-utils";
 export type TransformerSuccessEither = E.Right<"buildSuccess", TypeNode>;
 export type DataParserNotSupportedEither = E.Left<"dataParserNotSupport", DP.DataParser>;
 export type DataParserErrorEither = E.Left<"buildDataParserError", DP.DataParser>;
-export type SupportedDataParsers = DP.DataParsers | SDP.DataParserFile;
-export type MapContext = Map<SupportedDataParsers, TypeAliasDeclaration>;
+export type MapContext = Map<DP.DataParsers, TypeAliasDeclaration>;
 export type MapImportType = Map<string, string[]>;
 export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
 export type TransformerMode = "in" | "out";
@@ -18,4 +16,5 @@ export interface TransformerParams {
     buildError(): DataParserErrorEither;
     addImport(path: string, typeName: string): void;
 }
-export declare function createTransformer<GenericDataParser extends SupportedDataParsers>(support: (schema: SupportedDataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: SupportedDataParsers, params: TransformerParams) => MaybeTransformerEither;
+export type TransformerBuildFunction<GenericDataParser extends DP.DataParsers = DP.DataParsers> = (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: TransformerBuildFunction<GenericDataParser>): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/array.d.ts

@@ -1 +1,2 @@
-export declare const arrayTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const arrayTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/bigint.d.ts

@@ -1 +1,2 @@
-export declare const bigIntTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const bigIntTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/boolean.d.ts

@@ -1 +1,2 @@
-export declare const booleanTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const booleanTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/date.d.ts

@@ -1 +1,2 @@
-export declare const dateTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const dateTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/empty.d.ts

@@ -1 +1,2 @@
-export declare const emptyTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const emptyTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/file.d.ts

@@ -1 +1 @@
-export declare const fileTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export declare const fileTransformer: (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/index.d.ts

@@ -20,4 +20,4 @@ export * from "./union";
 export * from "./unknown";
 export * from "./date";
 export * from "./time";
-export declare const defaultTransformers: readonly [(schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];
+export declare const defaultTransformers: readonly [(schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];

package/dist/toTypescript/transformer/defaults/lazy.d.ts

@@ -1 +1,2 @@
-export declare const lazyTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const lazyTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/literal.d.ts

@@ -1 +1,2 @@
-export declare const literalTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const literalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/nil.d.ts

@@ -1 +1,2 @@
-export declare const nilTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const nilTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/nullable.d.ts

@@ -1 +1,2 @@
-export declare const nullableTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const nullableTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/number.d.ts

@@ -1 +1,2 @@
-export declare const numberTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const numberTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/object.d.ts

@@ -1 +1,2 @@
-export declare const objectTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const objectTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/optional.d.ts

@@ -1 +1,2 @@
-export declare const optionalTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const optionalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/pipe.d.ts

@@ -1 +1,2 @@
-export declare const pipeTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const pipeTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/record.d.ts

@@ -1 +1,2 @@
-export declare const recordTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const recordTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/recover.d.ts

@@ -1 +1,2 @@
-export declare const recoverTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const recoverTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/string.d.ts

@@ -1 +1,2 @@
-export declare const stringTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const stringTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/templateLiteral.d.ts

@@ -1 +1,2 @@
-export declare const templateLiteralTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const templateLiteralTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/time.d.ts

@@ -1 +1,2 @@
-export declare const timeTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const timeTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/transform.d.ts

@@ -1 +1,2 @@
-export declare const transformTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const transformTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/tuple.d.ts

@@ -1 +1,2 @@
-export declare const tupleTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const tupleTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/union.d.ts

@@ -1 +1,2 @@
-export declare const unionTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const unionTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/unknown.d.ts

@@ -1 +1,2 @@
-export declare const unknownTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const unknownTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/transformer.cjs

@@ -4,9 +4,6 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 
 function transformer(schema, params) {
-    if (schema.definition.overrideTypeNode?.[params.mode]) {
-        return utils.E.right("buildSuccess", schema.definition.overrideTypeNode[params.mode]);
-    }
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -53,16 +50,18 @@ function transformer(schema, params) {
             }
         },
     };
-    const result = utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (utils.E.isLeft(result)) {
-            if (utils.unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideTypescriptTransformer
+        ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)
+        : utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (utils.E.isLeft(result)) {
+                if (utils.unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (utils.E.isLeft(result)) {
         return result;
     }

package/dist/toTypescript/transformer/transformer.d.ts

@@ -1,12 +1,12 @@
-import { type DP } from "@duplojs/utils";
-import type { MapContext, DataParserNotSupportedEither, createTransformer, TransformerMode, DataParserErrorEither, MapImportType, SupportedDataParsers } from "./create";
+import { type DDataParser, type DP } from "@duplojs/utils";
+import type { MapContext, DataParserNotSupportedEither, createTransformer, TransformerMode, DataParserErrorEither, MapImportType } from "./create";
 import type { TransformerHook } from "./hook";
 export interface TransformerFunctionParams {
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
     readonly context: MapContext;
     readonly mode: TransformerMode;
     readonly hooks: readonly TransformerHook[];
-    readonly recursiveDataParsers: SupportedDataParsers[];
+    readonly recursiveDataParsers: DDataParser.DataParser[];
     readonly importType: MapImportType;
 }
 export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;

package/dist/toTypescript/transformer/transformer.mjs

@@ -1,10 +1,7 @@
-import { E, A, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 
 function transformer(schema, params) {
-    if (schema.definition.overrideTypeNode?.[params.mode]) {
-        return E.right("buildSuccess", schema.definition.overrideTypeNode[params.mode]);
-    }
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -51,16 +48,18 @@ function transformer(schema, params) {
             }
         },
     };
-    const result = A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (E.isLeft(result)) {
-            if (unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideTypescriptTransformer
+        ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)
+        : A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (E.isLeft(result)) {
+                if (unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (E.isLeft(result)) {
         return result;
     }

package/dist/utils/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var getRecursiveDataParser = require('./getRecursiveDataParser.cjs');
+
+
+
+exports.getRecursiveDataParser = getRecursiveDataParser.getRecursiveDataParser;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./getRecursiveDataParser";

package/dist/utils/index.mjs

@@ -0,0 +1 @@
+export { getRecursiveDataParser } from './getRecursiveDataParser.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -24,7 +24,7 @@
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tsconfig.test.json",
+    "test:types": "tsc -p tsconfig.test.json && npm -w integration run test:types",
     "test:lint": "eslint",
     "test:lint:fix": "eslint --fix",
     "prepare": "husky"
@@ -71,7 +71,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.5.1 <2.0.0",
+    "@duplojs/utils": ">=1.5.3 <2.0.0",
     "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
   },
   "dependencies": {