@duplojs/data-parser-tools 0.2.3 → 0.2.4

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/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;
@@ -36,7 +36,7 @@ export interface TransformerParams {
     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/transformer.cjs

@@ -33,22 +33,22 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return utils.E.right("buildSuccess", {
             schema: { $ref: buildRef(currentDeclaration.name, params.version) },
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            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) {
@@ -75,13 +75,13 @@ 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({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }

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

@@ -14,5 +14,5 @@ export declare function transformer(schema: DP.DataParser, params: TransformerFu
     readonly schema: {
         readonly $ref: string;
     };
-    readonly canBeUndefined: boolean;
+    readonly isOptional: boolean;
 }>;

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -31,22 +31,22 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return E.right("buildSuccess", {
             schema: { $ref: buildRef(currentDeclaration.name, params.version) },
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            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) {
@@ -73,13 +73,13 @@ 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({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }

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.3",
+  "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"