@duplojs/data-parser-tools 0.2.2 → 0.2.4

package/dist/toJsonSchema/index.cjs

@@ -38,6 +38,7 @@ exports.createToJsonSchemaKind = kind.createToJsonSchemaKind;
 exports.defaultTransformers = index.defaultTransformers;
 exports.createTransformer = create.createTransformer;
 exports.supportedVersions = create.supportedVersions;
+exports.buildRef = transformer.buildRef;
 exports.transformer = transformer.transformer;
 exports.arrayTransformer = array.arrayTransformer;
 exports.bigIntTransformer = bigint.bigIntTransformer;

package/dist/toJsonSchema/index.mjs

@@ -4,7 +4,7 @@ export { DataParserToJsonSchemaRenderError, render } from './render.mjs';
 export { createToJsonSchemaKind } from './kind.mjs';
 export { defaultTransformers } from './transformer/defaults/index.mjs';
 export { createTransformer, supportedVersions } from './transformer/create.mjs';
-export { transformer } from './transformer/transformer.mjs';
+export { buildRef, transformer } from './transformer/transformer.mjs';
 export { arrayTransformer } from './transformer/defaults/array.mjs';
 export { bigIntTransformer } from './transformer/defaults/bigint.mjs';
 export { booleanTransformer } from './transformer/defaults/boolean.mjs';

package/dist/toJsonSchema/override.cjs

@@ -6,7 +6,8 @@ dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, id
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => schema.construct({
-    ...schema.definition,
-    identifier,
-}));
+dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toJsonSchema/override.mjs

@@ -4,7 +4,8 @@ dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) =
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => schema.construct({
-    ...schema.definition,
-    identifier,
-}));
+dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toJsonSchema/render.cjs

@@ -16,21 +16,6 @@ class DataParserToJsonSchemaRenderError extends utils.kindHeritage("data-parser-
         this.error = error;
     }
 }
-function buildRef(name, version) {
-    if (version === create.supportedVersions.openApi3 || version === create.supportedVersions.openApi31) {
-        return { $ref: `#/components/schemas/${name}` };
-    }
-    if (version === create.supportedVersions.jsonSchema202012) {
-        return { $ref: `#/$defs/${name}` };
-    }
-    return { $ref: `#/definitions/${name}` };
-}
-function getDefinitionKey(version) {
-    if (version === create.supportedVersions.jsonSchema202012 || version === create.supportedVersions.openApi31) {
-        return "$defs";
-    }
-    return "definitions";
-}
 function render(schema, params) {
     const context = new Map(params.context);
     const version = create.supportedVersions[params.version];
@@ -58,23 +43,27 @@ function render(schema, params) {
             ...definitions,
             [params.identifier]: built.schema,
         };
-    if (utils.or(version, [
-        utils.equal(create.supportedVersions.openApi3),
-        utils.equal(create.supportedVersions.openApi31),
-    ])) {
-        return JSON.stringify({
+    if (version === create.supportedVersions.openApi3
+        || version === create.supportedVersions.openApi31) {
+        return {
+            $ref: transformer.buildRef(params.identifier, version),
             openapi: version,
             components: {
                 schemas: definitionsWithIdentifier,
             },
-            ...buildRef(params.identifier, version),
-        }, null, 4);
+        };
+    }
+    if (version === create.supportedVersions.jsonSchema202012) {
+        return {
+            $ref: transformer.buildRef(params.identifier, version),
+            $schema: version,
+            $defs: definitionsWithIdentifier,
+        };
     }
-    const definitionKey = getDefinitionKey(version);
     return {
+        $ref: transformer.buildRef(params.identifier, version),
         $schema: version,
-        ...buildRef(params.identifier, version),
-        [definitionKey]: definitionsWithIdentifier,
+        definitions: definitionsWithIdentifier,
     };
 }
 

package/dist/toJsonSchema/render.d.ts

@@ -1,13 +1,5 @@
-import { type DP } from "@duplojs/utils";
-import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type SupportedVersions } from "./transformer";
-export interface RenderParams {
-    readonly identifier: string;
-    readonly transformers: readonly ReturnType<typeof createTransformer>[];
-    readonly context?: MapContext;
-    readonly mode?: TransformerMode;
-    readonly hooks?: readonly TransformerHook[];
-    readonly version: SupportedVersions;
-}
+import { type DP, type Or, type IsEqual } from "@duplojs/utils";
+import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type SupportedVersions, type JsonSchema } from "./transformer";
 declare const DataParserToJsonSchemaRenderError_base: new (params: {
     "@DuplojsDataParserToolsToJsonSchema/data-parser-to-json-schema-render-error"?: unknown;
 }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToJsonSchema/data-parser-to-json-schema-render-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"data-parser-to-json-schema-render-error", unknown>, unknown>;
@@ -16,8 +8,34 @@ export declare class DataParserToJsonSchemaRenderError extends DataParserToJsonS
     error: DataParserNotSupportedEither | DataParserErrorEither;
     constructor(schema: DP.DataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
 }
-export declare function render(schema: DP.DataParsers, params: RenderParams): string | {
-    $ref: string;
-    $schema: "http://json-schema.org/draft-04/schema#" | "http://json-schema.org/draft-07/schema#" | "https://json-schema.org/draft/2020-12/schema";
-};
+export interface RenderParams<GenericVersion extends unknown> {
+    readonly identifier: string;
+    readonly transformers: readonly ReturnType<typeof createTransformer>[];
+    readonly context?: MapContext;
+    readonly mode?: TransformerMode;
+    readonly hooks?: readonly TransformerHook[];
+    readonly version: GenericVersion;
+}
+type RenderResult<GenericVersion extends keyof SupportedVersions> = Or<[
+    IsEqual<GenericVersion, "openApi3">,
+    IsEqual<GenericVersion, "openApi31">
+]> extends true ? {
+    $ref: `#/components/schemas/${string}`;
+    openapi: SupportedVersions[GenericVersion];
+    components: {
+        schemas: Record<string, JsonSchema>;
+    };
+} : Or<[
+    IsEqual<GenericVersion, "jsonSchema7">,
+    IsEqual<GenericVersion, "jsonSchema4">
+]> extends true ? {
+    $ref: `#/$defs/${string}`;
+    $schema: SupportedVersions[GenericVersion];
+    definitions: Record<string, JsonSchema>;
+} : IsEqual<GenericVersion, "jsonSchema202012"> extends true ? {
+    $ref: `#/definitions/${string}`;
+    $schema: SupportedVersions[GenericVersion];
+    $defs: Record<string, JsonSchema>;
+} : never;
+export declare function render<GenericVersion extends keyof SupportedVersions>(schema: DP.DataParsers, params: RenderParams<GenericVersion>): RenderResult<GenericVersion>;
 export {};

package/dist/toJsonSchema/render.mjs

@@ -1,9 +1,9 @@
-import { kindHeritage, E, unwrap, G, or, equal } from '@duplojs/utils';
+import { kindHeritage, E, unwrap, G } from '@duplojs/utils';
 import './transformer/index.mjs';
 import { createToJsonSchemaKind } from './kind.mjs';
 import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
 import { supportedVersions } from './transformer/create.mjs';
-import { transformer } from './transformer/transformer.mjs';
+import { transformer, buildRef } from './transformer/transformer.mjs';
 
 class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-json-schema-render-error", createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {
     schema;
@@ -14,21 +14,6 @@ class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-jso
         this.error = error;
     }
 }
-function buildRef(name, version) {
-    if (version === supportedVersions.openApi3 || version === supportedVersions.openApi31) {
-        return { $ref: `#/components/schemas/${name}` };
-    }
-    if (version === supportedVersions.jsonSchema202012) {
-        return { $ref: `#/$defs/${name}` };
-    }
-    return { $ref: `#/definitions/${name}` };
-}
-function getDefinitionKey(version) {
-    if (version === supportedVersions.jsonSchema202012 || version === supportedVersions.openApi31) {
-        return "$defs";
-    }
-    return "definitions";
-}
 function render(schema, params) {
     const context = new Map(params.context);
     const version = supportedVersions[params.version];
@@ -56,23 +41,27 @@ function render(schema, params) {
             ...definitions,
             [params.identifier]: built.schema,
         };
-    if (or(version, [
-        equal(supportedVersions.openApi3),
-        equal(supportedVersions.openApi31),
-    ])) {
-        return JSON.stringify({
+    if (version === supportedVersions.openApi3
+        || version === supportedVersions.openApi31) {
+        return {
+            $ref: buildRef(params.identifier, version),
             openapi: version,
             components: {
                 schemas: definitionsWithIdentifier,
             },
-            ...buildRef(params.identifier, version),
-        }, null, 4);
+        };
+    }
+    if (version === supportedVersions.jsonSchema202012) {
+        return {
+            $ref: buildRef(params.identifier, version),
+            $schema: version,
+            $defs: definitionsWithIdentifier,
+        };
     }
-    const definitionKey = getDefinitionKey(version);
     return {
+        $ref: buildRef(params.identifier, version),
         $schema: version,
-        ...buildRef(params.identifier, version),
-        [definitionKey]: definitionsWithIdentifier,
+        definitions: definitionsWithIdentifier,
     };
 }
 

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

@@ -9,7 +9,7 @@ export interface JsonSchemaAnyOf {
 export type JsonSchema = JsonSchemaRef | JsonSchemaAnyOf | JsonSchemaArray | JsonSchemaBigInt | JsonSchemaBoolean | JsonSchemaDate | JsonSchemaEmpty | JsonSchemaLiteral | JsonSchemaNil | JsonSchemaNullableAnyOf | JsonSchemaNumber | JsonSchemaObject | JsonSchemaRecord | JsonSchemaString | JsonSchemaTemplateLiteral | JsonSchemaTuple | JsonSchemaUnion | JsonSchemaUnknown | JsonSchemaTime;
 export interface TransformerSuccess {
     readonly schema: JsonSchema;
-    readonly canBeUndefined: boolean;
+    readonly isOptional: boolean;
 }
 export type TransformerSuccessEither = E.EitherRight<"buildSuccess", TransformerSuccess>;
 export type DataParserNotSupportedEither = E.EitherLeft<"dataParserNotSupport", DP.DataParser>;
@@ -17,7 +17,7 @@ export type DataParserErrorEither = E.EitherLeft<"buildDataParserError", DP.Data
 export interface MapContextValue {
     readonly name: string;
     readonly schema?: JsonSchema;
-    readonly canBeUndefined: boolean;
+    readonly isOptional: boolean;
 }
 export type MapContext = Map<DP.DataParsers, MapContextValue>;
 export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
@@ -29,14 +29,14 @@ export declare const supportedVersions: {
     readonly openApi3: "https://spec.openapis.org/oas/3.0.3";
     readonly openApi31: "https://spec.openapis.org/oas/3.1.0";
 };
-export type SupportedVersions = keyof typeof supportedVersions;
-export type SupportedVersionsUrl = typeof supportedVersions[SupportedVersions];
+export type SupportedVersions = typeof supportedVersions;
+export type SupportedVersionsUrl = typeof supportedVersions[keyof SupportedVersions];
 export interface TransformerParams {
     readonly mode: TransformerMode;
     readonly context: MapContext;
     readonly version: SupportedVersionsUrl;
     transformer(schema: DP.DataParser): MaybeTransformerEither;
-    success(result: JsonSchema, canBeUndefined?: boolean): TransformerSuccessEither;
+    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;

package/dist/toJsonSchema/transformer/defaults/literal.cjs

@@ -3,45 +3,81 @@
 var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
-const literalTransformer = create.createTransformer(utils.DP.literalKind.has, (schema, { success, }) => {
+function isOldVersion(version) {
+    return (version === "http://json-schema.org/draft-04/schema#"
+        || version === "https://spec.openapis.org/oas/3.0.3");
+}
+const literalTransformer = create.createTransformer(utils.DP.literalKind.has, (schema, { success, version, }) => {
     const reduced = utils.A.reduce(schema.definition.value, utils.A.reduceFrom({
         literals: [],
-        canBeUndefined: false,
+        isOptional: false,
     }), ({ element, lastValue, next, nextWithObject, }) => utils.P.match(element)
-        .when(utils.isType("undefined"), () => nextWithObject(lastValue, { canBeUndefined: true }))
+        .when(utils.isType("undefined"), () => nextWithObject(lastValue, { isOptional: true }))
         .when(utils.isType("bigint"), (value) => nextWithObject(lastValue, {
-        literals: utils.A.push(lastValue.literals, {
-            const: value.toString(),
-            type: "string",
-        }),
+        literals: utils.A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value.toString()],
+                type: "string",
+            }
+            : {
+                const: value.toString(),
+                type: "string",
+            }),
     }))
         .when(utils.isType("string"), (value) => nextWithObject(lastValue, {
-        literals: utils.A.push(lastValue.literals, {
-            const: value,
-            type: "string",
-        }),
+        literals: utils.A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "string",
+            }
+            : {
+                const: value,
+                type: "string",
+            }),
     }))
         .when(utils.isType("number"), (value) => nextWithObject(lastValue, {
-        literals: utils.A.push(lastValue.literals, {
-            const: value,
-            type: Number.isInteger(value) ? "integer" : "number",
-        }),
+        literals: utils.A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }
+            : {
+                const: value,
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }),
     }))
         .when(utils.isType("boolean"), (value) => nextWithObject(lastValue, {
-        literals: utils.A.push(lastValue.literals, {
-            const: value,
-            type: "boolean",
-        }),
+        literals: utils.A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "boolean",
+            }
+            : {
+                const: value,
+                type: "boolean",
+            }),
     }))
         .when(utils.isType("null"), () => nextWithObject(lastValue, {
-        literals: utils.A.push(lastValue.literals, {
-            const: null,
+        literals: utils.A.push(lastValue.literals, utils.P.match(version)
+            .with("https://spec.openapis.org/oas/3.0.3", utils.justReturn({
+            enum: [null],
+        }))
+            .with("http://json-schema.org/draft-04/schema#", utils.justReturn({
+            type: "null",
+            enum: [null],
+        }))
+            .otherwise(utils.justReturn({
             type: "null",
-        }),
+            const: null,
+        }))),
     }))
         .otherwise(() => next(lastValue)));
     const schemaDefinition = utils.pipe(reduced.literals, utils.P.when(utils.A.lengthEqual(0), () => ({})), utils.P.when(utils.A.lengthEqual(1), utils.A.first), utils.P.otherwise((value) => ({ anyOf: value })));
-    return success(schemaDefinition, reduced.canBeUndefined);
+    return success(schemaDefinition, reduced.isOptional);
 });
 
 exports.literalTransformer = literalTransformer;

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

@@ -1,6 +1,14 @@
 import { DP } from "@duplojs/utils";
-export interface JsonSchemaLiteral {
-    const?: string | number | boolean | null;
-    type?: "string" | "number" | "integer" | "boolean" | "null";
-}
+type JsonPrimitive = string | number | boolean | null;
+type JsonType = "string" | "number" | "integer" | "boolean" | "null";
+export type JsonSchemaLiteral = {
+    const: JsonPrimitive;
+    type: JsonType;
+} | {
+    enum: readonly [JsonPrimitive];
+    type: JsonType;
+} | {
+    enum: readonly [null];
+};
 export declare const literalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export {};

package/dist/toJsonSchema/transformer/defaults/literal.mjs

@@ -1,45 +1,81 @@
-import { DP, A, P, isType, pipe } from '@duplojs/utils';
+import { DP, A, P, isType, justReturn, pipe } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
-const literalTransformer = createTransformer(DP.literalKind.has, (schema, { success, }) => {
+function isOldVersion(version) {
+    return (version === "http://json-schema.org/draft-04/schema#"
+        || version === "https://spec.openapis.org/oas/3.0.3");
+}
+const literalTransformer = createTransformer(DP.literalKind.has, (schema, { success, version, }) => {
     const reduced = A.reduce(schema.definition.value, A.reduceFrom({
         literals: [],
-        canBeUndefined: false,
+        isOptional: false,
     }), ({ element, lastValue, next, nextWithObject, }) => P.match(element)
-        .when(isType("undefined"), () => nextWithObject(lastValue, { canBeUndefined: true }))
+        .when(isType("undefined"), () => nextWithObject(lastValue, { isOptional: true }))
         .when(isType("bigint"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value.toString(),
-            type: "string",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value.toString()],
+                type: "string",
+            }
+            : {
+                const: value.toString(),
+                type: "string",
+            }),
     }))
         .when(isType("string"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: "string",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "string",
+            }
+            : {
+                const: value,
+                type: "string",
+            }),
     }))
         .when(isType("number"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: Number.isInteger(value) ? "integer" : "number",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }
+            : {
+                const: value,
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }),
     }))
         .when(isType("boolean"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: "boolean",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "boolean",
+            }
+            : {
+                const: value,
+                type: "boolean",
+            }),
     }))
         .when(isType("null"), () => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: null,
+        literals: A.push(lastValue.literals, P.match(version)
+            .with("https://spec.openapis.org/oas/3.0.3", justReturn({
+            enum: [null],
+        }))
+            .with("http://json-schema.org/draft-04/schema#", justReturn({
+            type: "null",
+            enum: [null],
+        }))
+            .otherwise(justReturn({
             type: "null",
-        }),
+            const: null,
+        }))),
     }))
         .otherwise(() => next(lastValue)));
     const schemaDefinition = pipe(reduced.literals, P.when(A.lengthEqual(0), () => ({})), P.when(A.lengthEqual(1), A.first), P.otherwise((value) => ({ anyOf: value })));
-    return success(schemaDefinition, reduced.canBeUndefined);
+    return success(schemaDefinition, reduced.isOptional);
 });
 
 export { literalTransformer };

package/dist/toJsonSchema/transformer/defaults/nullable.cjs

@@ -9,12 +9,21 @@ const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has,
         return innerResult;
     }
     const inner = utils.unwrap(innerResult);
-    return utils.pipe(mode, utils.P.match("in", () => ({
+    return utils.pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => utils.P.match(value)
+        .with(utils.P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => ({
         anyOf: [
             inner.schema,
             { type: "null" },
         ],
-    })), utils.P.match("out", () => inner.schema), utils.P.exhaustive, (schema) => success(schema, inner.canBeUndefined));
+    }))
+        .with({ mode: "out" }, () => inner.schema)
+        .exhaustive(), (schema) => success(schema, inner.isOptional));
 });
 
 exports.nullableTransformer = nullableTransformer;

package/dist/toJsonSchema/transformer/defaults/nullable.mjs

@@ -7,12 +7,21 @@ const nullableTransformer = createTransformer(DP.nullableKind.has, (schema, { tr
         return innerResult;
     }
     const inner = unwrap(innerResult);
-    return pipe(mode, P.match("in", () => ({
+    return pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => P.match(value)
+        .with(P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => ({
         anyOf: [
             inner.schema,
             { type: "null" },
         ],
-    })), P.match("out", () => inner.schema), P.exhaustive, (schema) => success(schema, inner.canBeUndefined));
+    }))
+        .with({ mode: "out" }, () => inner.schema)
+        .exhaustive(), (schema) => success(schema, inner.isOptional));
 });
 
 export { nullableTransformer };

package/dist/toJsonSchema/transformer/defaults/object.cjs

@@ -14,7 +14,7 @@ const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (sch
             ...lastValue.properties,
             [key]: inner.schema,
         },
-        required: inner.canBeUndefined
+        required: inner.isOptional
             ? lastValue.required
             : utils.A.push(lastValue.required ?? [], key),
     })))));

package/dist/toJsonSchema/transformer/defaults/object.mjs

@@ -12,7 +12,7 @@ const objectTransformer = createTransformer(DP.objectKind.has, (schema, { transf
             ...lastValue.properties,
             [key]: inner.schema,
         },
-        required: inner.canBeUndefined
+        required: inner.isOptional
             ? lastValue.required
             : A.push(lastValue.required ?? [], key),
     })))));

package/dist/toJsonSchema/transformer/defaults/optional.cjs

@@ -3,6 +3,15 @@
 var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
-const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, success, mode, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((inner) => utils.pipe(mode, utils.P.match("in", () => true), utils.P.match("out", () => inner.canBeUndefined), utils.P.exhaustive, (value) => success(inner.schema, value)))));
+const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, success, mode, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((inner) => utils.pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => utils.P.match(value)
+    .with(utils.P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => true)
+    .with({ mode: "out" }, () => inner.isOptional)
+    .exhaustive(), (isOptional) => success(inner.schema, isOptional)))));
 
 exports.optionalTransformer = optionalTransformer;

package/dist/toJsonSchema/transformer/defaults/optional.mjs

@@ -1,6 +1,15 @@
 import { DP, pipe, E, P } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
-const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, success, mode, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((inner) => pipe(mode, P.match("in", () => true), P.match("out", () => inner.canBeUndefined), P.exhaustive, (value) => success(inner.schema, value)))));
+const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, success, mode, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((inner) => pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => P.match(value)
+    .with(P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => true)
+    .with({ mode: "out" }, () => inner.isOptional)
+    .exhaustive(), (isOptional) => success(inner.schema, isOptional)))));
 
 export { optionalTransformer };

package/dist/toJsonSchema/transformer/defaults/union.cjs

@@ -4,9 +4,9 @@ var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
 const unionTransformer = create.createTransformer(utils.DP.unionKind.has, (schema, { transformer, success, }) => {
-    let canBeUndefined = false;
+    let isOptional = false;
     const optionsResult = utils.A.reduce(schema.definition.options, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => utils.pipe(transformer(element), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((option) => {
-        canBeUndefined ||= option.canBeUndefined;
+        isOptional ||= option.isOptional;
         return nextPush(lastValue, option.schema);
     })));
     if (utils.E.isLeft(optionsResult)) {
@@ -14,7 +14,7 @@ const unionTransformer = create.createTransformer(utils.DP.unionKind.has, (schem
     }
     return success({
         anyOf: optionsResult,
-    }, canBeUndefined);
+    }, isOptional);
 });
 
 exports.unionTransformer = unionTransformer;

package/dist/toJsonSchema/transformer/defaults/union.mjs

@@ -2,9 +2,9 @@ import { DP, A, pipe, when, E } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
 const unionTransformer = createTransformer(DP.unionKind.has, (schema, { transformer, success, }) => {
-    let canBeUndefined = false;
+    let isOptional = false;
     const optionsResult = A.reduce(schema.definition.options, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => pipe(transformer(element), when(E.isLeft, exit), E.whenIsRight((option) => {
-        canBeUndefined ||= option.canBeUndefined;
+        isOptional ||= option.isOptional;
         return nextPush(lastValue, option.schema);
     })));
     if (E.isLeft(optionsResult)) {
@@ -12,7 +12,7 @@ const unionTransformer = createTransformer(DP.unionKind.has, (schema, { transfor
     }
     return success({
         anyOf: optionsResult,
-    }, canBeUndefined);
+    }, isOptional);
 });
 
 export { unionTransformer };

package/dist/toJsonSchema/transformer/index.cjs

@@ -9,5 +9,6 @@ var index = require('./defaults/index.cjs');
 
 exports.createTransformer = create.createTransformer;
 exports.supportedVersions = create.supportedVersions;
+exports.buildRef = transformer.buildRef;
 exports.transformer = transformer.transformer;
 exports.defaultTransformers = index.defaultTransformers;

package/dist/toJsonSchema/transformer/index.mjs

@@ -1,4 +1,4 @@
 export { createTransformer, supportedVersions } from './create.mjs';
-export { transformer } from './transformer.mjs';
+export { buildRef, transformer } from './transformer.mjs';
 import './hook.mjs';
 export { defaultTransformers } from './defaults/index.mjs';

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -3,13 +3,14 @@
 var utils = require('@duplojs/utils');
 
 function buildRef(name, version) {
-    if (version === "https://spec.openapis.org/oas/3.0.3" || version === "https://spec.openapis.org/oas/3.1.0") {
-        return { $ref: `#/components/schemas/${name}` };
+    if (version === "https://spec.openapis.org/oas/3.0.3"
+        || version === "https://spec.openapis.org/oas/3.1.0") {
+        return `#/components/schemas/${name}`;
     }
     if (version === "https://json-schema.org/draft/2020-12/schema") {
-        return { $ref: `#/$defs/${name}` };
+        return `#/$defs/${name}`;
     }
-    return { $ref: `#/definitions/${name}` };
+    return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
@@ -31,23 +32,23 @@ function transformer(schema, params) {
     const currentDeclaration = params.context.get(currentSchema);
     if (currentDeclaration) {
         return utils.E.right("buildSuccess", {
-            schema: buildRef(currentDeclaration.name, params.version),
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            schema: { $ref: buildRef(currentDeclaration.name, params.version) },
+            isOptional: currentDeclaration.isOptional,
         });
     }
     const currentIdentifier = utils.whenElse(params.recursiveDataParsers, utils.A.includes(currentSchema), () => {
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
-            canBeUndefined: false,
+            isOptional: false,
         });
         return identifier;
     }, utils.justReturn(currentSchema.definition.identifier));
     const functionParams = {
-        success(result, canBeUndefined = false) {
+        success(result, isOptional = false) {
             return utils.E.right("buildSuccess", {
                 schema: result,
-                canBeUndefined,
+                isOptional,
             });
         },
         transformer(schema) {
@@ -74,15 +75,16 @@ function transformer(schema, params) {
         return result;
     }
     if (currentIdentifier) {
-        const { schema: builtSchema, canBeUndefined } = utils.unwrap(result);
+        const { schema: builtSchema, isOptional } = utils.unwrap(result);
         params.context.set(currentSchema, {
             name: currentIdentifier,
             schema: builtSchema,
-            canBeUndefined,
+            isOptional,
         });
-        return functionParams.success(buildRef(currentIdentifier, params.version), canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }
 
+exports.buildRef = buildRef;
 exports.transformer = transformer;

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

@@ -1,4 +1,4 @@
-import { type DP } from "@duplojs/utils";
+import { E, type DP } from "@duplojs/utils";
 import { type MapContext, type DataParserNotSupportedEither, type createTransformer, type TransformerMode, type SupportedVersionsUrl, type DataParserErrorEither } from "./create";
 import { type TransformerHook } from "./hook";
 export interface TransformerFunctionParams {
@@ -9,4 +9,10 @@ export interface TransformerFunctionParams {
     readonly hooks: readonly TransformerHook[];
     readonly recursiveDataParsers: DP.DataParser[];
 }
-export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
+export declare function buildRef(name: string, version: SupportedVersionsUrl): string;
+export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither | E.EitherRight<"buildSuccess", {
+    readonly schema: {
+        readonly $ref: string;
+    };
+    readonly isOptional: boolean;
+}>;

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,13 +1,14 @@
 import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
 
 function buildRef(name, version) {
-    if (version === "https://spec.openapis.org/oas/3.0.3" || version === "https://spec.openapis.org/oas/3.1.0") {
-        return { $ref: `#/components/schemas/${name}` };
+    if (version === "https://spec.openapis.org/oas/3.0.3"
+        || version === "https://spec.openapis.org/oas/3.1.0") {
+        return `#/components/schemas/${name}`;
     }
     if (version === "https://json-schema.org/draft/2020-12/schema") {
-        return { $ref: `#/$defs/${name}` };
+        return `#/$defs/${name}`;
     }
-    return { $ref: `#/definitions/${name}` };
+    return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
@@ -29,23 +30,23 @@ function transformer(schema, params) {
     const currentDeclaration = params.context.get(currentSchema);
     if (currentDeclaration) {
         return E.right("buildSuccess", {
-            schema: buildRef(currentDeclaration.name, params.version),
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            schema: { $ref: buildRef(currentDeclaration.name, params.version) },
+            isOptional: currentDeclaration.isOptional,
         });
     }
     const currentIdentifier = whenElse(params.recursiveDataParsers, A.includes(currentSchema), () => {
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
-            canBeUndefined: false,
+            isOptional: false,
         });
         return identifier;
     }, justReturn(currentSchema.definition.identifier));
     const functionParams = {
-        success(result, canBeUndefined = false) {
+        success(result, isOptional = false) {
             return E.right("buildSuccess", {
                 schema: result,
-                canBeUndefined,
+                isOptional,
             });
         },
         transformer(schema) {
@@ -72,15 +73,15 @@ function transformer(schema, params) {
         return result;
     }
     if (currentIdentifier) {
-        const { schema: builtSchema, canBeUndefined } = unwrap(result);
+        const { schema: builtSchema, isOptional } = unwrap(result);
         params.context.set(currentSchema, {
             name: currentIdentifier,
             schema: builtSchema,
-            canBeUndefined,
+            isOptional,
         });
-        return functionParams.success(buildRef(currentIdentifier, params.version), canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }
 
-export { transformer };
+export { buildRef, transformer };

package/dist/toTypescript/index.cjs

@@ -29,6 +29,7 @@ var union = require('./transformer/defaults/union.cjs');
 var unknown = require('./transformer/defaults/unknown.cjs');
 var date = require('./transformer/defaults/date.cjs');
 var time = require('./transformer/defaults/time.cjs');
+var includesUndefinedTypeNode = require('./transformer/includesUndefinedTypeNode.cjs');
 
 
 
@@ -60,3 +61,4 @@ exports.unionTransformer = union.unionTransformer;
 exports.unknownTransformer = unknown.unknownTransformer;
 exports.dateTransformer = date.dateTransformer;
 exports.timeTransformer = time.timeTransformer;
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;

package/dist/toTypescript/index.mjs

@@ -27,3 +27,4 @@ export { unionTransformer } from './transformer/defaults/union.mjs';
 export { unknownTransformer } from './transformer/defaults/unknown.mjs';
 export { dateTransformer } from './transformer/defaults/date.mjs';
 export { timeTransformer } from './transformer/defaults/time.mjs';
+export { includesUndefinedTypeNode } from './transformer/includesUndefinedTypeNode.mjs';

package/dist/toTypescript/override.cjs

@@ -6,10 +6,8 @@ dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, id
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => ({
-    ...schema,
-    definition: {
-        ...schema.definition,
-        identifier,
-    },
-}));
+dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toTypescript/override.mjs

@@ -4,10 +4,8 @@ dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) =
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => ({
-    ...schema,
-    definition: {
-        ...schema.definition,
-        identifier,
-    },
-}));
+dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toTypescript/transformer/defaults/nullable.cjs

@@ -10,10 +10,19 @@ const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has,
         return innerResult;
     }
     const innerType = utils.unwrap(innerResult);
-    return utils.pipe(mode, utils.P.match("in", () => utils.pipe(typescript.factory.createNull(), typescript.factory.createLiteralTypeNode, (value) => typescript.factory.createUnionTypeNode([
+    return utils.pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => utils.P.match(value)
+        .with(utils.P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => utils.pipe(typescript.factory.createNull(), typescript.factory.createLiteralTypeNode, (value) => typescript.factory.createUnionTypeNode([
         innerType,
         value,
-    ]))), utils.P.match("out", () => innerType), utils.P.exhaustive, success);
+    ])))
+        .with({ mode: "out" }, () => innerType)
+        .exhaustive(), success);
 });
 
 exports.nullableTransformer = nullableTransformer;

package/dist/toTypescript/transformer/defaults/nullable.mjs

@@ -8,10 +8,19 @@ const nullableTransformer = createTransformer(DP.nullableKind.has, (schema, { tr
         return innerResult;
     }
     const innerType = unwrap(innerResult);
-    return pipe(mode, P.match("in", () => pipe(factory.createNull(), factory.createLiteralTypeNode, (value) => factory.createUnionTypeNode([
+    return pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => P.match(value)
+        .with(P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => pipe(factory.createNull(), factory.createLiteralTypeNode, (value) => factory.createUnionTypeNode([
         innerType,
         value,
-    ]))), P.match("out", () => innerType), P.exhaustive, success);
+    ])))
+        .with({ mode: "out" }, () => innerType)
+        .exhaustive(), success);
 });
 
 export { nullableTransformer };

package/dist/toTypescript/transformer/defaults/object.cjs

@@ -3,17 +3,9 @@
 var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
+var includesUndefinedTypeNode = require('../includesUndefinedTypeNode.cjs');
 
-function includesUndefinedTypeNode(typeNode) {
-    if (typeNode.kind === typescript.SyntaxKind.UndefinedKeyword) {
-        return true;
-    }
-    if (typescript.isUnionTypeNode(typeNode)) {
-        return typeNode.types.some((subTypeNode) => includesUndefinedTypeNode(subTypeNode));
-    }
-    return false;
-}
 const regexIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (schema, { transformer, success, }) => utils.pipe(schema.definition.shape, utils.O.entries, utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => utils.pipe(transformer(value), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((typeNode) => utils.pipe(includesUndefinedTypeNode(typeNode), utils.P.match(true, () => typescript.factory.createToken(typescript.SyntaxKind.QuestionToken)), utils.P.match(false, () => undefined), utils.P.exhaustive, (optional) => utils.pipe(key, utils.whenElse(utils.S.test(regexIdentifier), typescript.factory.createIdentifier, typescript.factory.createStringLiteral), (propertyName) => typescript.factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => utils.A.push(lastValue, typeElement), next))))), utils.when(utils.isType("array"), utils.innerPipe(typescript.factory.createTypeLiteralNode, success))));
+const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (schema, { transformer, success, }) => utils.pipe(schema.definition.shape, utils.O.entries, utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => utils.pipe(transformer(value), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((typeNode) => utils.pipe(includesUndefinedTypeNode.includesUndefinedTypeNode(typeNode), utils.P.match(true, () => typescript.factory.createToken(typescript.SyntaxKind.QuestionToken)), utils.P.match(false, () => undefined), utils.P.exhaustive, (optional) => utils.pipe(key, utils.whenElse(utils.S.test(regexIdentifier), typescript.factory.createIdentifier, typescript.factory.createStringLiteral), (propertyName) => typescript.factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => utils.A.push(lastValue, typeElement), next))))), utils.when(utils.isType("array"), utils.innerPipe(typescript.factory.createTypeLiteralNode, success))));
 
 exports.objectTransformer = objectTransformer;

package/dist/toTypescript/transformer/defaults/object.mjs

@@ -1,16 +1,8 @@
 import { DP, pipe, O, A, when, E, P, whenElse, S, isType, innerPipe } from '@duplojs/utils';
-import { SyntaxKind, isUnionTypeNode, factory } from 'typescript';
+import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
+import { includesUndefinedTypeNode } from '../includesUndefinedTypeNode.mjs';
 
-function includesUndefinedTypeNode(typeNode) {
-    if (typeNode.kind === SyntaxKind.UndefinedKeyword) {
-        return true;
-    }
-    if (isUnionTypeNode(typeNode)) {
-        return typeNode.types.some((subTypeNode) => includesUndefinedTypeNode(subTypeNode));
-    }
-    return false;
-}
 const regexIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const objectTransformer = createTransformer(DP.objectKind.has, (schema, { transformer, success, }) => pipe(schema.definition.shape, O.entries, A.reduce(A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => pipe(transformer(value), when(E.isLeft, exit), E.whenIsRight((typeNode) => pipe(includesUndefinedTypeNode(typeNode), P.match(true, () => factory.createToken(SyntaxKind.QuestionToken)), P.match(false, () => undefined), P.exhaustive, (optional) => pipe(key, whenElse(S.test(regexIdentifier), factory.createIdentifier, factory.createStringLiteral), (propertyName) => factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => A.push(lastValue, typeElement), next))))), when(isType("array"), innerPipe(factory.createTypeLiteralNode, success))));
 

package/dist/toTypescript/transformer/defaults/optional.cjs

@@ -4,9 +4,18 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, mode, success, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((innerType) => utils.pipe(mode, utils.P.match("in", () => typescript.factory.createUnionTypeNode([
+const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, mode, success, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((innerType) => utils.pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => utils.P.match(value)
+    .with(utils.P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => typescript.factory.createUnionTypeNode([
     innerType,
     typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword),
-])), utils.P.match("out", () => innerType), utils.P.exhaustive, success))));
+]))
+    .with({ mode: "out" }, () => innerType)
+    .exhaustive(), success))));
 
 exports.optionalTransformer = optionalTransformer;

package/dist/toTypescript/transformer/defaults/optional.mjs

@@ -2,9 +2,18 @@ import { DP, pipe, E, P } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, mode, success, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((innerType) => pipe(mode, P.match("in", () => factory.createUnionTypeNode([
+const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, mode, success, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((innerType) => pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => P.match(value)
+    .with(P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => factory.createUnionTypeNode([
     innerType,
     factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword),
-])), P.match("out", () => innerType), P.exhaustive, success))));
+]))
+    .with({ mode: "out" }, () => innerType)
+    .exhaustive(), success))));
 
 export { optionalTransformer };

package/dist/toTypescript/transformer/defaults/record.cjs

@@ -3,6 +3,7 @@
 var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
+var includesUndefinedTypeNode = require('../includesUndefinedTypeNode.cjs');
 
 const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ definition: { key, value } }, { transformer, success, }) => {
     const keyResult = transformer(key);
@@ -15,7 +16,7 @@ const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ d
     }
     const keyType = utils.unwrap(keyResult);
     const valueType = utils.unwrap(valueResult);
-    const recordType = typescript.factory.createTypeReferenceNode("Record", [keyType, valueType]);
+    const recordType = utils.pipe(typescript.factory.createTypeReferenceNode("Record", [keyType, valueType]), utils.when(() => includesUndefinedTypeNode.includesUndefinedTypeNode(valueType), (recodeTypeNode) => typescript.factory.createTypeReferenceNode("Partial", [recodeTypeNode])));
     return success(recordType);
 });
 

package/dist/toTypescript/transformer/defaults/record.mjs

@@ -1,6 +1,7 @@
-import { DP, E, unwrap } from '@duplojs/utils';
+import { DP, E, unwrap, pipe, when } from '@duplojs/utils';
 import { factory } from 'typescript';
 import { createTransformer } from '../create.mjs';
+import { includesUndefinedTypeNode } from '../includesUndefinedTypeNode.mjs';
 
 const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: { key, value } }, { transformer, success, }) => {
     const keyResult = transformer(key);
@@ -13,7 +14,7 @@ const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: {
     }
     const keyType = unwrap(keyResult);
     const valueType = unwrap(valueResult);
-    const recordType = factory.createTypeReferenceNode("Record", [keyType, valueType]);
+    const recordType = pipe(factory.createTypeReferenceNode("Record", [keyType, valueType]), when(() => includesUndefinedTypeNode(valueType), (recodeTypeNode) => factory.createTypeReferenceNode("Partial", [recodeTypeNode])));
     return success(recordType);
 });
 

package/dist/toTypescript/transformer/includesUndefinedTypeNode.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+
+function includesUndefinedTypeNode(typeNode) {
+    if (typeNode.kind === typescript.SyntaxKind.UndefinedKeyword) {
+        return true;
+    }
+    if (typescript.isUnionTypeNode(typeNode)) {
+        return utils.A.some(typeNode.types, (subTypeNode) => includesUndefinedTypeNode(subTypeNode));
+    }
+    return false;
+}
+
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode;

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

@@ -0,0 +1,2 @@
+import { type TypeNode } from "typescript";
+export declare function includesUndefinedTypeNode(typeNode: TypeNode): boolean;

package/dist/toTypescript/transformer/includesUndefinedTypeNode.mjs

@@ -0,0 +1,14 @@
+import { A } from '@duplojs/utils';
+import { SyntaxKind, isUnionTypeNode } from 'typescript';
+
+function includesUndefinedTypeNode(typeNode) {
+    if (typeNode.kind === SyntaxKind.UndefinedKeyword) {
+        return true;
+    }
+    if (isUnionTypeNode(typeNode)) {
+        return A.some(typeNode.types, (subTypeNode) => includesUndefinedTypeNode(subTypeNode));
+    }
+    return false;
+}
+
+export { includesUndefinedTypeNode };

package/dist/toTypescript/transformer/index.cjs

@@ -4,9 +4,11 @@ var create = require('./create.cjs');
 var transformer = require('./transformer.cjs');
 require('./hook.cjs');
 var index = require('./defaults/index.cjs');
+var includesUndefinedTypeNode = require('./includesUndefinedTypeNode.cjs');
 
 
 
 exports.createTransformer = create.createTransformer;
 exports.transformer = transformer.transformer;
 exports.defaultTransformers = index.defaultTransformers;
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;

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

@@ -2,4 +2,5 @@ export * from "./create";
 export * from "./transformer";
 export * from "./hook";
 export * from "./defaults";
+export * from "./includesUndefinedTypeNode";
 export { defaultTransformers } from "./defaults";

package/dist/toTypescript/transformer/index.mjs

@@ -2,3 +2,4 @@ export { createTransformer } from './create.mjs';
 export { transformer } from './transformer.mjs';
 import './hook.mjs';
 export { defaultTransformers } from './defaults/index.mjs';
+export { includesUndefinedTypeNode } from './includesUndefinedTypeNode.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -71,7 +71,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.3.30 <2.0.0"
+    "@duplojs/utils": ">=1.4.36 <2.0.0"
   },
   "dependencies": {
     "typescript": "5.9.2"