@duplojs/data-parser-tools 0.2.8 → 0.3.0

package/dist/toJsonSchema/override.cjs

@@ -2,16 +2,16 @@
 
 var dataParser = require('@duplojs/utils/dataParser');
 
-dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -22,7 +22,7 @@ dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransf
     }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
     newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;

package/dist/toJsonSchema/override.d.ts

@@ -1,6 +1,6 @@
 import { type TransformerBuildFunction, type TransformerSuccess } from "./transformer/create";
 declare module "@duplojs/utils/dataParser" {
-    interface DataParser {
+    interface DataParserBase {
         /**
          * @deprecated this method mutated the dataParser by adding an identifier
          */

package/dist/toJsonSchema/override.mjs

@@ -1,15 +1,15 @@
-import { dataParserInit } from '@duplojs/utils/dataParser';
+import { dataParserBaseInit } from '@duplojs/utils/dataParser';
 
-dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+dataParserBaseInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -20,7 +20,7 @@ dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (sc
     }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+dataParserBaseInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
     newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;

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

@@ -3,7 +3,7 @@
 var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
-const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ definition: { key, value, requireKey } }, { transformer, success, }) => {
+const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ definition: { key, value, baseData } }, { transformer, success, }) => {
     const keyResult = transformer(key);
     if (utils.E.isLeft(keyResult)) {
         return keyResult;
@@ -14,7 +14,8 @@ const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ d
     }
     const keySchema = utils.unwrap(keyResult).schema;
     const valueSchema = utils.unwrap(valueResult).schema;
-    if (requireKey) {
+    const requireKey = utils.O.keys(baseData);
+    if (utils.A.minElements(requireKey, 1)) {
         const properties = utils.A.reduce(requireKey, utils.A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, { [element]: valueSchema }));
         return success({
             type: "object",
@@ -23,7 +24,6 @@ const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ d
             additionalProperties: false,
             propertyNames: { enum: requireKey },
             minProperties: requireKey.length,
-            maxProperties: requireKey.length,
         });
     }
     return success({

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

@@ -1,7 +1,7 @@
-import { DP, E, unwrap, A } from '@duplojs/utils';
+import { DP, E, unwrap, O, A } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
-const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: { key, value, requireKey } }, { transformer, success, }) => {
+const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: { key, value, baseData } }, { transformer, success, }) => {
     const keyResult = transformer(key);
     if (E.isLeft(keyResult)) {
         return keyResult;
@@ -12,7 +12,8 @@ const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: {
     }
     const keySchema = unwrap(keyResult).schema;
     const valueSchema = unwrap(valueResult).schema;
-    if (requireKey) {
+    const requireKey = O.keys(baseData);
+    if (A.minElements(requireKey, 1)) {
         const properties = A.reduce(requireKey, A.reduceFrom({}), ({ element, lastValue, nextWithObject }) => nextWithObject(lastValue, { [element]: valueSchema }));
         return success({
             type: "object",
@@ -21,7 +22,6 @@ const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: {
             additionalProperties: false,
             propertyNames: { enum: requireKey },
             minProperties: requireKey.length,
-            maxProperties: requireKey.length,
         });
     }
     return success({

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

@@ -7,11 +7,11 @@ const stringTransformer = create.createTransformer(utils.DP.stringKind.has, (sch
     const definition = utils.A.reduce(schema.definition.checkers, utils.A.reduceFrom({ type: "string" }), ({ element: checker, lastValue, nextWithObject, next }) => utils.P.match(checker)
         .when(utils.DP.checkerStringMinKind.has, ({ definition }) => nextWithObject(lastValue, { minLength: definition.min }))
         .when(utils.DP.checkerStringMaxKind.has, ({ definition }) => nextWithObject(lastValue, { maxLength: definition.max }))
-        .when(utils.DP.checkerStringRegexKind.has, ({ definition }) => nextWithObject(lastValue, { pattern: definition.regex.source }))
+        .when(utils.DP.checkerRegexKind.has, ({ definition }) => nextWithObject(lastValue, { pattern: definition.regex.source }))
         .when(utils.DP.checkerUrlKind.has, () => nextWithObject(lastValue, { format: "uri" }))
         .when(utils.DP.checkerEmailKind.has, ({ definition }) => nextWithObject(lastValue, {
         format: "email",
-        pattern: lastValue.pattern ?? definition.pattern.source,
+        pattern: lastValue.pattern ?? definition.regex.source,
     }))
         .otherwise(() => next(lastValue)));
     if (schema.definition.coerce && mode === "in") {

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

@@ -5,11 +5,11 @@ const stringTransformer = createTransformer(DP.stringKind.has, (schema, { succes
     const definition = A.reduce(schema.definition.checkers, A.reduceFrom({ type: "string" }), ({ element: checker, lastValue, nextWithObject, next }) => P.match(checker)
         .when(DP.checkerStringMinKind.has, ({ definition }) => nextWithObject(lastValue, { minLength: definition.min }))
         .when(DP.checkerStringMaxKind.has, ({ definition }) => nextWithObject(lastValue, { maxLength: definition.max }))
-        .when(DP.checkerStringRegexKind.has, ({ definition }) => nextWithObject(lastValue, { pattern: definition.regex.source }))
+        .when(DP.checkerRegexKind.has, ({ definition }) => nextWithObject(lastValue, { pattern: definition.regex.source }))
         .when(DP.checkerUrlKind.has, () => nextWithObject(lastValue, { format: "uri" }))
         .when(DP.checkerEmailKind.has, ({ definition }) => nextWithObject(lastValue, {
         format: "email",
-        pattern: lastValue.pattern ?? definition.pattern.source,
+        pattern: lastValue.pattern ?? definition.regex.source,
     }))
         .otherwise(() => next(lastValue)));
     if (schema.definition.coerce && mode === "in") {

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

@@ -5,7 +5,7 @@ var create = require('../create.cjs');
 
 const templateLiteralTransformer = create.createTransformer(utils.DP.templateLiteralKind.has, (schema, { success, transformer, }) => {
     const result = utils.DP.findRecordRequiredKeyOnTemplateLiteralPart(schema.definition.template);
-    if (result) {
+    if (utils.A.minElements(result, 1)) {
         return transformer(utils.DP.literal(result));
     }
     return success({

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

@@ -1,9 +1,9 @@
-import { DP } from '@duplojs/utils';
+import { DP, A } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
 const templateLiteralTransformer = createTransformer(DP.templateLiteralKind.has, (schema, { success, transformer, }) => {
     const result = DP.findRecordRequiredKeyOnTemplateLiteralPart(schema.definition.template);
-    if (result) {
+    if (A.minElements(result, 1)) {
         return transformer(DP.literal(result));
     }
     return success({

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -36,14 +36,18 @@ function transformer(schema, params) {
             isOptional: currentDeclaration.isOptional,
         });
     }
-    const currentIdentifier = utils.whenElse(params.recursiveDataParsers, utils.A.includes(currentSchema), () => {
+    const currentIdentifier = utils.justExec(() => {
+        if (!utils.A.includes(params.recursiveDataParsers, currentSchema)
+            && !currentSchema.definition.identifier) {
+            return undefined;
+        }
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
             isOptional: false,
         });
         return identifier;
-    }, utils.justReturn(currentSchema.definition.identifier));
+    });
     const functionParams = {
         success(result, isOptional = false) {
             return utils.E.right("buildSuccess", {

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,4 +1,4 @@
-import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, justExec, unwrap } from '@duplojs/utils';
 
 function buildRef(name, version) {
     if (version === "openApi3"
@@ -34,14 +34,18 @@ function transformer(schema, params) {
             isOptional: currentDeclaration.isOptional,
         });
     }
-    const currentIdentifier = whenElse(params.recursiveDataParsers, A.includes(currentSchema), () => {
+    const currentIdentifier = justExec(() => {
+        if (!A.includes(params.recursiveDataParsers, currentSchema)
+            && !currentSchema.definition.identifier) {
+            return undefined;
+        }
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
             isOptional: false,
         });
         return identifier;
-    }, justReturn(currentSchema.definition.identifier));
+    });
     const functionParams = {
         success(result, isOptional = false) {
             return E.right("buildSuccess", {

package/dist/toTypescript/override.cjs

@@ -2,16 +2,16 @@
 
 var dataParser = require('@duplojs/utils/dataParser');
 
-dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -22,7 +22,7 @@ dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransf
     }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
     newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;

package/dist/toTypescript/override.d.ts

@@ -1,7 +1,7 @@
 import { type TypeNode } from "typescript";
 import { type TransformerBuildFunction } from "./transformer";
 declare module "@duplojs/utils/dataParser" {
-    interface DataParser {
+    interface DataParserBase {
         /**
          * @deprecated this method mutated the dataParser by adding an identifier
          */

package/dist/toTypescript/override.mjs

@@ -1,15 +1,15 @@
-import { dataParserInit } from '@duplojs/utils/dataParser';
+import { dataParserBaseInit } from '@duplojs/utils/dataParser';
 
-dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+dataParserBaseInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -20,7 +20,7 @@ dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (sc
     }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
+dataParserBaseInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
     newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -71,8 +71,8 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.5.6 <2.0.0",
-    "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
+    "@duplojs/utils": ">=1.8.1 <2.0.0",
+    "@duplojs/server-utils": ">=0.3.0 < 1.0.0"
   },
   "dependencies": {
     "typescript": "5.9.2"