@duplojs/data-parser-tools 0.2.1 → 0.2.3

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/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

@@ -29,8 +29,8 @@ 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;

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,7 +32,7 @@ function transformer(schema, params) {
     const currentDeclaration = params.context.get(currentSchema);
     if (currentDeclaration) {
         return utils.E.right("buildSuccess", {
-            schema: buildRef(currentDeclaration.name, params.version),
+            schema: { $ref: buildRef(currentDeclaration.name, params.version) },
             canBeUndefined: currentDeclaration.canBeUndefined,
         });
     }
@@ -80,9 +81,10 @@ function transformer(schema, params) {
             schema: builtSchema,
             canBeUndefined,
         });
-        return functionParams.success(buildRef(currentIdentifier, params.version), canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
     }
     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 canBeUndefined: 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,7 +30,7 @@ function transformer(schema, params) {
     const currentDeclaration = params.context.get(currentSchema);
     if (currentDeclaration) {
         return E.right("buildSuccess", {
-            schema: buildRef(currentDeclaration.name, params.version),
+            schema: { $ref: buildRef(currentDeclaration.name, params.version) },
             canBeUndefined: currentDeclaration.canBeUndefined,
         });
     }
@@ -78,9 +79,9 @@ function transformer(schema, params) {
             schema: builtSchema,
             canBeUndefined,
         });
-        return functionParams.success(buildRef(currentIdentifier, params.version), canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
     }
     return result;
 }
 
-export { transformer };
+export { buildRef, transformer };

package/dist/utils/getRecursiveDataParser.cjs

@@ -6,28 +6,42 @@ function getRecursiveDataParser(schema) {
     const countMap = new Map();
     void (function countDataParser(schema) {
         utils.P.match(schema)
-            .when((value) => (utils.DP.stringKind.has(value)
-            || utils.DP.stringKind.has(value)
-            || utils.DP.numberKind.has(value)
-            || utils.DP.nilKind.has(value)
-            || utils.DP.dateKind.has(value)
-            || utils.DP.emptyKind.has(value)
-            || utils.DP.bigIntKind.has(value)
-            || utils.DP.booleanKind.has(value)
-            || utils.DP.literalKind.has(value)
-            || utils.DP.unknownKind.has(value)
-            || utils.DP.templateLiteralKind.has(value)
-            || utils.DP.recordKind.has(value)), () => void 0)
-            .when((value) => (utils.DP.nullableKind.has(value)
-            || utils.DP.optionalKind.has(value)
-            || utils.DP.recoverKind.has(value)
-            || utils.DP.transformKind.has(value)), (dataParser) => void countDataParser(dataParser.definition.inner))
+            .when(utils.hasSomeKinds([
+            utils.DP.stringKind,
+            utils.DP.stringKind,
+            utils.DP.numberKind,
+            utils.DP.nilKind,
+            utils.DP.dateKind,
+            utils.DP.emptyKind,
+            utils.DP.bigIntKind,
+            utils.DP.booleanKind,
+            utils.DP.literalKind,
+            utils.DP.unknownKind,
+            utils.DP.templateLiteralKind,
+            utils.DP.recordKind,
+        ]), () => void 0)
+            .when(utils.hasSomeKinds([
+            utils.DP.nullableKind,
+            utils.DP.optionalKind,
+            utils.DP.recoverKind,
+            utils.DP.transformKind,
+        ]), (dataParser) => void countDataParser(dataParser.definition.inner))
             .when(utils.DP.lazyKind.has, (dataParser) => void countDataParser(dataParser.definition.getter.value))
             .when(utils.DP.pipeKind.has, (dataParser) => {
             countDataParser(dataParser.definition.input);
             countDataParser(dataParser.definition.output);
         })
-            .when(utils.DP.unionKind.has, (dataParser) => utils.A.map(dataParser.definition.options, countDataParser))
+            .when(utils.DP.unionKind.has, (dataParser) => {
+            const count = (countMap.get(dataParser) ?? 0) + 1;
+            countMap.set(dataParser, count);
+            if (count > 1) {
+                return;
+            }
+            utils.A.map(dataParser.definition.options, countDataParser);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
+        })
             .when(utils.DP.arrayKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
             countMap.set(dataParser, count);
@@ -35,6 +49,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             countDataParser(dataParser.definition.element);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(utils.DP.objectKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
@@ -43,6 +60,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             utils.pipe(dataParser.definition.shape, utils.O.entries, utils.A.map(([, value]) => void countDataParser(value)));
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(utils.DP.tupleKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
@@ -51,6 +71,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             utils.A.map(dataParser.definition.shape, countDataParser);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(utils.DP.dataParserKind.has, () => void 0)
             .exhaustive();

package/dist/utils/getRecursiveDataParser.mjs

@@ -1,31 +1,45 @@
-import { P, DP, A, pipe, O, G } from '@duplojs/utils';
+import { P, hasSomeKinds, DP, A, pipe, O, G } from '@duplojs/utils';
 
 function getRecursiveDataParser(schema) {
     const countMap = new Map();
     void (function countDataParser(schema) {
         P.match(schema)
-            .when((value) => (DP.stringKind.has(value)
-            || DP.stringKind.has(value)
-            || DP.numberKind.has(value)
-            || DP.nilKind.has(value)
-            || DP.dateKind.has(value)
-            || DP.emptyKind.has(value)
-            || DP.bigIntKind.has(value)
-            || DP.booleanKind.has(value)
-            || DP.literalKind.has(value)
-            || DP.unknownKind.has(value)
-            || DP.templateLiteralKind.has(value)
-            || DP.recordKind.has(value)), () => void 0)
-            .when((value) => (DP.nullableKind.has(value)
-            || DP.optionalKind.has(value)
-            || DP.recoverKind.has(value)
-            || DP.transformKind.has(value)), (dataParser) => void countDataParser(dataParser.definition.inner))
+            .when(hasSomeKinds([
+            DP.stringKind,
+            DP.stringKind,
+            DP.numberKind,
+            DP.nilKind,
+            DP.dateKind,
+            DP.emptyKind,
+            DP.bigIntKind,
+            DP.booleanKind,
+            DP.literalKind,
+            DP.unknownKind,
+            DP.templateLiteralKind,
+            DP.recordKind,
+        ]), () => void 0)
+            .when(hasSomeKinds([
+            DP.nullableKind,
+            DP.optionalKind,
+            DP.recoverKind,
+            DP.transformKind,
+        ]), (dataParser) => void countDataParser(dataParser.definition.inner))
             .when(DP.lazyKind.has, (dataParser) => void countDataParser(dataParser.definition.getter.value))
             .when(DP.pipeKind.has, (dataParser) => {
             countDataParser(dataParser.definition.input);
             countDataParser(dataParser.definition.output);
         })
-            .when(DP.unionKind.has, (dataParser) => A.map(dataParser.definition.options, countDataParser))
+            .when(DP.unionKind.has, (dataParser) => {
+            const count = (countMap.get(dataParser) ?? 0) + 1;
+            countMap.set(dataParser, count);
+            if (count > 1) {
+                return;
+            }
+            A.map(dataParser.definition.options, countDataParser);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
+        })
             .when(DP.arrayKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
             countMap.set(dataParser, count);
@@ -33,6 +47,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             countDataParser(dataParser.definition.element);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(DP.objectKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
@@ -41,6 +58,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             pipe(dataParser.definition.shape, O.entries, A.map(([, value]) => void countDataParser(value)));
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(DP.tupleKind.has, (dataParser) => {
             const count = (countMap.get(dataParser) ?? 0) + 1;
@@ -49,6 +69,9 @@ function getRecursiveDataParser(schema) {
                 return;
             }
             A.map(dataParser.definition.shape, countDataParser);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
         })
             .when(DP.dataParserKind.has, () => void 0)
             .exhaustive();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [