@duplojs/data-parser-tools 0.2.3 → 0.2.5

package/README.md

@@ -1,2 +1,167 @@
-# @duplojs/data-parser-tools
-[![NPM version](https://img.shields.io/npm/v/@duplojs/data-parser-tools)](https://www.npmjs.com/package/@duplojs/data-parser-tools)
+<a name="top"></a>
+
+<p align="center">
+  <img src="https://utils.duplojs.dev/images/logo.png" alt="logo" width="250px" />
+</p>
+<p align="center">
+  <span style="font-size: 24px; font-weight: bold;">DataParser Tools</span>
+</p>
+<p align="center">
+  <a href='#'>
+    <img src='https://img.shields.io/badge/types-TypeScript-blue?logo=typescript&style=plastic' alt='coverage' />
+  </a>
+  <a href="#">
+    <img src="https://img.shields.io/badge/coverage-100%25-green?style=plastic" alt="lang">
+  </a>
+  <a href="https://www.npmjs.com/package/@duplojs/data-parser-tools">
+    <img src="https://img.shields.io/npm/v/@duplojs/data-parser-tools" alt="lang">
+  </a>
+</p>
+
+`@duplojs/data-parser-tools` is a library that convert `dataParser` schema to choice format (typescript, jsonSchema)
+
+## Installation
+
+To consume `@duplojs/data-parser-tools`, you need to install the npm package and zod.
+```bash
+npm install @duplojs/data-parser-tools@0 @duplojs/utils@1 @duplojs/server-utils@0
+```
+
+## Usage
+
+The library exposes two converters:
+- `@duplojs/data-parser-tools/toTypescript`
+- `@duplojs/data-parser-tools/toJsonSchema`
+
+### 1) Generate a TypeScript type with `render`
+
+```ts
+import { DPE } from "@duplojs/utils";
+import { render, defaultTransformers } from "@duplojs/data-parser-tools/toTypescript";
+
+const userSchema = DPE.object({
+	id: DPE.number(),
+	name: DPE.string(),
+}).addIdentifier("User");
+
+const tsType = render(userSchema, {
+	identifier: "User",
+	mode: "out",
+	transformers: defaultTransformers,
+});
+
+console.log(tsType);
+// export type User = { id: number; name: string; };
+```
+
+`identifier` is the final exported name.  
+`mode` can be:
+- `"out"`: output format (strict)
+- `"in"`: input format (includes accepted input variants, for example date/time)
+
+### 2) Generate a JSON Schema
+
+```ts
+import { DPE } from "@duplojs/utils";
+import { render, defaultTransformers } from "@duplojs/data-parser-tools/toJsonSchema";
+
+const userSchema = DPE.object({
+	id: DPE.number(),
+	name: DPE.string(),
+}).addIdentifier("User");
+
+const jsonSchema = render(userSchema, {
+	identifier: "User",
+	mode: "out",
+	transformers: defaultTransformers,
+	version: "jsonSchema7", // jsonSchema4 | jsonSchema7 | jsonSchema202012 | openApi3 | openApi31
+});
+
+console.log(jsonSchema.$ref); // "#/definitions/User"
+```
+
+### 3) Add an identifier to a schema (`addIdentifier`)
+
+`addIdentifier` clones the schema and attaches an internal reusable name during rendering.
+
+```ts
+const base = DPE.object({ value: DPE.string() });
+const named = base.addIdentifier("MyNamedSchema");
+```
+
+If the name passed to `render({ identifier })` differs from the schema identifier, an alias is generated (for example: `export type PublicName = MyNamedSchema;`).
+
+### 4) Use hooks
+
+Hooks let you intercept/replace a schema before transformation.
+- `output("next", schema)`: continue the hook chain
+- `output("stop", schema)`: stop the chain and transform this schema
+
+```ts
+import { DPE } from "@duplojs/utils";
+import { render, defaultTransformers, type TransformerHook } from "@duplojs/data-parser-tools/toTypescript";
+
+const forceStringHook: TransformerHook = ({ output }) => output("stop", DPE.string());
+
+const result = render(DPE.number(), {
+	identifier: "HookExample",
+	mode: "out",
+	transformers: defaultTransformers,
+	hooks: [forceStringHook],
+});
+
+console.log(result);
+// export type HookExample = string;
+```
+
+### 5) Recursive schemas
+
+Recursive references are supported through `DPE.lazy(...)`.
+
+```ts
+import { DPE } from "@duplojs/utils";
+import { render, defaultTransformers } from "@duplojs/data-parser-tools/toTypescript";
+
+type Node = { children: Node[] };
+
+const nodeSchema: DPE.Contract<Node> = DPE.object({
+	children: DPE.array(DPE.lazy(() => nodeSchema)),
+}).addIdentifier("Node");
+
+const result = render(nodeSchema, {
+	identifier: "Node",
+	mode: "out",
+	transformers: defaultTransformers,
+});
+```
+
+### 6) Custom types: `date`, `time`, `file`
+
+```ts
+import { DPE } from "@duplojs/utils";
+import { SDP } from "@duplojs/server-utils";
+import { render, defaultTransformers } from "@duplojs/data-parser-tools/toTypescript";
+
+const schema = DPE.object({
+	createdAt: DPE.date(),
+	startAt: DPE.time(),
+	avatar: SDP.file(),
+});
+
+const outType = render(schema, {
+	identifier: "PayloadOut",
+	mode: "out",
+	transformers: defaultTransformers,
+});
+
+const inType = render(schema, {
+	identifier: "PayloadIn",
+	mode: "in",
+	transformers: defaultTransformers,
+});
+```
+
+In practice:
+- `date` / `time` in `"out"` produce template-literals (`date...`, `time...`)
+- `date` / `time` in `"in"` also accept additional input variants
+- `file` maps to `FileInterface` (imported from `@duplojs/server-utils/file`)

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

@@ -4,8 +4,8 @@ var utils = require('@duplojs/utils');
 require('./transformer/index.cjs');
 var kind = require('./kind.cjs');
 var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
-var create = require('./transformer/create.cjs');
 var transformer = require('./transformer/transformer.cjs');
+var create = require('./transformer/create.cjs');
 
 class DataParserToJsonSchemaRenderError extends utils.kindHeritage("data-parser-to-json-schema-render-error", kind.createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {
     schema;
@@ -18,13 +18,12 @@ class DataParserToJsonSchemaRenderError extends utils.kindHeritage("data-parser-
 }
 function render(schema, params) {
     const context = new Map(params.context);
-    const version = create.supportedVersions[params.version];
     const result = transformer.transformer(schema, {
         ...params,
         context,
         mode: params.mode ?? "out",
         hooks: params.hooks ?? [],
-        version,
+        version: params.version,
         recursiveDataParsers: getRecursiveDataParser.getRecursiveDataParser(schema),
     });
     if (utils.E.isLeft(result)) {
@@ -43,26 +42,26 @@ function render(schema, params) {
             ...definitions,
             [params.identifier]: built.schema,
         };
-    if (version === create.supportedVersions.openApi3
-        || version === create.supportedVersions.openApi31) {
+    if (params.version === "openApi3"
+        || params.version === "openApi31") {
         return {
-            $ref: transformer.buildRef(params.identifier, version),
-            openapi: version,
+            $ref: transformer.buildRef(params.identifier, params.version),
+            openapi: create.supportedVersions[params.version],
             components: {
                 schemas: definitionsWithIdentifier,
             },
         };
     }
-    if (version === create.supportedVersions.jsonSchema202012) {
+    if (params.version === "jsonSchema202012") {
         return {
-            $ref: transformer.buildRef(params.identifier, version),
-            $schema: version,
+            $ref: transformer.buildRef(params.identifier, params.version),
+            $schema: params.version,
             $defs: definitionsWithIdentifier,
         };
     }
     return {
-        $ref: transformer.buildRef(params.identifier, version),
-        $schema: version,
+        $ref: transformer.buildRef(params.identifier, params.version),
+        $schema: create.supportedVersions[params.version],
         definitions: definitionsWithIdentifier,
     };
 }

package/dist/toJsonSchema/render.d.ts

@@ -1,14 +1,14 @@
 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";
+import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type MapperSupportedVersions, type JsonSchema, type SupportedVersions } 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>;
+}, parentParams: readonly [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>;
 export declare class DataParserToJsonSchemaRenderError extends DataParserToJsonSchemaRenderError_base {
     schema: DP.DataParsers;
     error: DataParserNotSupportedEither | DataParserErrorEither;
     constructor(schema: DP.DataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
 }
-export interface RenderParams<GenericVersion extends unknown> {
+export interface RenderParams<GenericVersion extends SupportedVersions> {
     readonly identifier: string;
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
     readonly context?: MapContext;
@@ -16,12 +16,12 @@ export interface RenderParams<GenericVersion extends unknown> {
     readonly hooks?: readonly TransformerHook[];
     readonly version: GenericVersion;
 }
-type RenderResult<GenericVersion extends keyof SupportedVersions> = Or<[
+type RenderResult<GenericVersion extends SupportedVersions> = Or<[
     IsEqual<GenericVersion, "openApi3">,
     IsEqual<GenericVersion, "openApi31">
 ]> extends true ? {
     $ref: `#/components/schemas/${string}`;
-    openapi: SupportedVersions[GenericVersion];
+    openapi: MapperSupportedVersions[GenericVersion];
     components: {
         schemas: Record<string, JsonSchema>;
     };
@@ -30,12 +30,12 @@ type RenderResult<GenericVersion extends keyof SupportedVersions> = Or<[
     IsEqual<GenericVersion, "jsonSchema4">
 ]> extends true ? {
     $ref: `#/$defs/${string}`;
-    $schema: SupportedVersions[GenericVersion];
+    $schema: MapperSupportedVersions[GenericVersion];
     definitions: Record<string, JsonSchema>;
 } : IsEqual<GenericVersion, "jsonSchema202012"> extends true ? {
     $ref: `#/definitions/${string}`;
-    $schema: SupportedVersions[GenericVersion];
+    $schema: MapperSupportedVersions[GenericVersion];
     $defs: Record<string, JsonSchema>;
 } : never;
-export declare function render<GenericVersion extends keyof SupportedVersions>(schema: DP.DataParsers, params: RenderParams<GenericVersion>): RenderResult<GenericVersion>;
+export declare function render<GenericVersion extends SupportedVersions>(schema: DP.DataParsers, params: RenderParams<GenericVersion>): RenderResult<GenericVersion>;
 export {};

package/dist/toJsonSchema/render.mjs

@@ -2,8 +2,8 @@ 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, buildRef } from './transformer/transformer.mjs';
+import { supportedVersions } from './transformer/create.mjs';
 
 class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-json-schema-render-error", createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {
     schema;
@@ -16,13 +16,12 @@ class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-jso
 }
 function render(schema, params) {
     const context = new Map(params.context);
-    const version = supportedVersions[params.version];
     const result = transformer(schema, {
         ...params,
         context,
         mode: params.mode ?? "out",
         hooks: params.hooks ?? [],
-        version,
+        version: params.version,
         recursiveDataParsers: getRecursiveDataParser(schema),
     });
     if (E.isLeft(result)) {
@@ -41,26 +40,26 @@ function render(schema, params) {
             ...definitions,
             [params.identifier]: built.schema,
         };
-    if (version === supportedVersions.openApi3
-        || version === supportedVersions.openApi31) {
+    if (params.version === "openApi3"
+        || params.version === "openApi31") {
         return {
-            $ref: buildRef(params.identifier, version),
-            openapi: version,
+            $ref: buildRef(params.identifier, params.version),
+            openapi: supportedVersions[params.version],
             components: {
                 schemas: definitionsWithIdentifier,
             },
         };
     }
-    if (version === supportedVersions.jsonSchema202012) {
+    if (params.version === "jsonSchema202012") {
         return {
-            $ref: buildRef(params.identifier, version),
-            $schema: version,
+            $ref: buildRef(params.identifier, params.version),
+            $schema: params.version,
             $defs: definitionsWithIdentifier,
         };
     }
     return {
-        $ref: buildRef(params.identifier, version),
-        $schema: version,
+        $ref: buildRef(params.identifier, params.version),
+        $schema: supportedVersions[params.version],
         definitions: definitionsWithIdentifier,
     };
 }

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

@@ -1,15 +1,16 @@
 import { type DP, E } from "@duplojs/utils";
 import type { JsonSchemaArray, JsonSchemaBigInt, JsonSchemaBoolean, JsonSchemaDate, JsonSchemaEmpty, JsonSchemaLiteral, JsonSchemaNil, JsonSchemaNullableAnyOf, JsonSchemaNumber, JsonSchemaObject, JsonSchemaRecord, JsonSchemaString, JsonSchemaTemplateLiteral, JsonSchemaTuple, JsonSchemaUnion, JsonSchemaUnknown, JsonSchemaTime } from "./defaults";
+import { type OpenapiJsonSchemaFile } from "./defaults/file";
 export interface JsonSchemaRef {
     $ref: string;
 }
 export interface JsonSchemaAnyOf {
     anyOf: JsonSchema[];
 }
-export type JsonSchema = JsonSchemaRef | JsonSchemaAnyOf | JsonSchemaArray | JsonSchemaBigInt | JsonSchemaBoolean | JsonSchemaDate | JsonSchemaEmpty | JsonSchemaLiteral | JsonSchemaNil | JsonSchemaNullableAnyOf | JsonSchemaNumber | JsonSchemaObject | JsonSchemaRecord | JsonSchemaString | JsonSchemaTemplateLiteral | JsonSchemaTuple | JsonSchemaUnion | JsonSchemaUnknown | JsonSchemaTime;
+export type JsonSchema = JsonSchemaRef | JsonSchemaAnyOf | JsonSchemaArray | JsonSchemaBigInt | JsonSchemaBoolean | JsonSchemaDate | JsonSchemaEmpty | JsonSchemaLiteral | JsonSchemaNil | JsonSchemaNullableAnyOf | JsonSchemaNumber | JsonSchemaObject | JsonSchemaRecord | JsonSchemaString | JsonSchemaTemplateLiteral | JsonSchemaTuple | JsonSchemaUnion | JsonSchemaUnknown | JsonSchemaTime | OpenapiJsonSchemaFile;
 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 +18,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 +30,15 @@ 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 = typeof supportedVersions;
-export type SupportedVersionsUrl = typeof supportedVersions[keyof SupportedVersions];
+export type MapperSupportedVersions = typeof supportedVersions;
+export type SupportedVersions = keyof typeof supportedVersions;
+export type SupportedVersionsUrl = typeof supportedVersions[SupportedVersions];
 export interface TransformerParams {
     readonly mode: TransformerMode;
     readonly context: MapContext;
-    readonly version: SupportedVersionsUrl;
+    readonly version: SupportedVersions;
     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/date.cjs

@@ -6,8 +6,7 @@ var create = require('../create.cjs');
 const dateTransformer = create.createTransformer(utils.DP.dateKind.has, (schema, { success, mode, }) => {
     const base = {
         type: "string",
-        pattern: utils.D.theDateRegex.source,
-        format: "date-time",
+        pattern: utils.D.serializeTheDateRegex.source,
     };
     if (mode === "in" && schema.definition.coerce) {
         return success({

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

@@ -4,8 +4,7 @@ import { createTransformer } from '../create.mjs';
 const dateTransformer = createTransformer(DP.dateKind.has, (schema, { success, mode, }) => {
     const base = {
         type: "string",
-        pattern: D.theDateRegex.source,
-        format: "date-time",
+        pattern: D.serializeTheDateRegex.source,
     };
     if (mode === "in" && schema.definition.coerce) {
         return success({

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

@@ -0,0 +1,17 @@
+'use strict';
+
+var serverUtils = require('@duplojs/server-utils');
+var create = require('../create.cjs');
+
+const fileTransformer = create.createTransformer(serverUtils.SDP.fileKind.has, (schema, { success, version, buildError, }) => {
+    if (version !== "openApi3"
+        && version !== "openApi31") {
+        return buildError();
+    }
+    return success({
+        type: "string",
+        format: "binary",
+    });
+});
+
+exports.fileTransformer = fileTransformer;

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

@@ -0,0 +1,5 @@
+export interface OpenapiJsonSchemaFile {
+    type: "string";
+    format: "binary";
+}
+export declare const fileTransformer: (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

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

@@ -0,0 +1,15 @@
+import { SDP } from '@duplojs/server-utils';
+import { createTransformer } from '../create.mjs';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (schema, { success, version, buildError, }) => {
+    if (version !== "openApi3"
+        && version !== "openApi31") {
+        return buildError();
+    }
+    return success({
+        type: "string",
+        format: "binary",
+    });
+});
+
+export { fileTransformer };

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

@@ -22,6 +22,7 @@ var tuple = require('./tuple.cjs');
 var union = require('./union.cjs');
 var unknown = require('./unknown.cjs');
 var time = require('./time.cjs');
+var file = require('./file.cjs');
 
 const defaultTransformers = [
     array.arrayTransformer,
@@ -46,6 +47,7 @@ const defaultTransformers = [
     union.unionTransformer,
     unknown.unknownTransformer,
     time.timeTransformer,
+    file.fileTransformer,
 ];
 
 exports.arrayTransformer = array.arrayTransformer;

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

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

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

@@ -20,6 +20,7 @@ import { tupleTransformer } from './tuple.mjs';
 import { unionTransformer } from './union.mjs';
 import { unknownTransformer } from './unknown.mjs';
 import { timeTransformer } from './time.mjs';
+import { fileTransformer } from './file.mjs';
 
 const defaultTransformers = [
     arrayTransformer,
@@ -44,6 +45,7 @@ const defaultTransformers = [
     unionTransformer,
     unknownTransformer,
     timeTransformer,
+    fileTransformer,
 ];
 
 export { arrayTransformer, bigIntTransformer, booleanTransformer, dateTransformer, defaultTransformers, emptyTransformer, lazyTransformer, literalTransformer, nilTransformer, nullableTransformer, numberTransformer, objectTransformer, optionalTransformer, pipeTransformer, recordTransformer, recoverTransformer, stringTransformer, templateLiteralTransformer, timeTransformer, transformTransformer, tupleTransformer, unionTransformer, unknownTransformer };

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 === "jsonSchema4"
+        || version === "openApi3");
+}
+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("openApi3", utils.justReturn({
+            enum: [null],
+        }))
+            .with("jsonSchema4", 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;