@palmares/schemas 0.0.1 → 0.1.0

package/dist/esm/src/validators/schema.js

@@ -1,5 +1,6 @@
 export function optional(args) {
     return {
+        name: 'optional',
         type: 'high',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
@@ -33,6 +34,7 @@ export function optional(args) {
 }
 export function nullable(args) {
     return {
+        name: 'nullable',
         type: 'high',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
@@ -48,7 +50,7 @@ export function nullable(args) {
                         {
                             isValid: false,
                             message: args.message,
-                            code: 'cannot_be_null',
+                            code: 'null',
                             // eslint-disable-next-line ts/no-unnecessary-condition
                             path: path || []
                         }
@@ -66,6 +68,7 @@ export function nullable(args) {
 }
 export function checkType(args) {
     return {
+        name: 'checkType',
         type: 'medium',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
@@ -92,6 +95,7 @@ export function checkType(args) {
 }
 export function is(args) {
     return {
+        name: 'is',
         type: 'medium',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{

package/dist/esm/src/validators/string.js

@@ -1,6 +1,8 @@
 export function stringValidation() {
     return {
+        name: 'string',
         type: 'medium',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             return {
                 parsed: value,
@@ -8,6 +10,7 @@ export function stringValidation() {
                     {
                         isValid: typeof value === 'string',
                         code: 'string',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: 'The value must be a string. Received: ' + typeof value
                     }
@@ -18,15 +21,18 @@ export function stringValidation() {
 }
 export function maxLength(args) {
     return {
+        name: 'maxLength',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
+            const isValid = value.length <= args.value;
             return {
                 parsed: value,
                 errors: isValid ? [] : [
                     {
                         isValid: false,
                         code: 'maxLength',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -37,15 +43,18 @@ export function maxLength(args) {
 }
 export function minLength(args) {
     return {
+        name: 'minLength',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
+            const isValid = value.length >= args.value;
             return {
                 parsed: value,
                 errors: isValid ? [] : [
                     {
                         isValid: false,
                         code: 'minLength',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -56,7 +65,9 @@ export function minLength(args) {
 }
 export function endsWith(args) {
     return {
+        name: 'endsWith',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = value.endsWith(args.value);
             return {
@@ -65,6 +76,7 @@ export function endsWith(args) {
                     {
                         isValid: false,
                         code: 'endsWith',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -75,7 +87,9 @@ export function endsWith(args) {
 }
 export function startsWith(args) {
     return {
+        name: 'startsWith',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = value.startsWith(args.value);
             return {
@@ -84,6 +98,7 @@ export function startsWith(args) {
                     {
                         isValid: false,
                         code: 'startsWith',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -94,7 +109,9 @@ export function startsWith(args) {
 }
 export function includes(args) {
     return {
+        name: 'includes',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = value.includes(args.value);
             return {
@@ -103,6 +120,7 @@ export function includes(args) {
                     {
                         isValid: false,
                         code: 'includes',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -113,7 +131,9 @@ export function includes(args) {
 }
 export function regex(args) {
     return {
+        name: 'regex',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = args.value.test(value);
             return {
@@ -122,6 +142,7 @@ export function regex(args) {
                     {
                         isValid: false,
                         code: 'regex',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -135,7 +156,9 @@ export function uuid(args) {
     //   /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
     const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
     return {
+        name: 'uuid',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = uuidRegex.test(value);
             return {
@@ -144,6 +167,7 @@ export function uuid(args) {
                     {
                         isValid: false,
                         code: 'uuid',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }
@@ -154,8 +178,11 @@ export function uuid(args) {
 }
 export function email(args) {
     const emailRegex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+    console.log('aquiiiiii');
     return {
+        name: 'email',
         type: 'low',
+        // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
             const isValid = emailRegex.test(value);
             return {
@@ -164,6 +191,7 @@ export function email(args) {
                     {
                         isValid: false,
                         code: 'email',
+                        // eslint-disable-next-line ts/no-unnecessary-condition
                         path: path || [],
                         message: args.message
                     }

package/dist/esm/src/validators/union.js

@@ -1,6 +1,7 @@
 export function unionValidation(schemas) {
     return {
-        type: 'high',
+        name: 'union',
+        type: 'medium',
         callback: async (value, path, options)=>{
             const parsedValues = {
                 parsed: value,
@@ -22,8 +23,8 @@ export function unionValidation(schemas) {
                         errors: []
                     };
                 } else if (startingToInternalBubbleUpLength < (options.toInternalToBubbleUp?.length || 0)) {
-                    // If there is a new toInternalToBubbleUp we should remove the ones that we added since this is not a valid schema,
-                    // we shouldn't be calling the `toInternal` on that schemas.
+                    // If there is a new toInternalToBubbleUp we should remove the ones that we added since this is not a
+                    // valid schema, we shouldn't be calling the `toInternal` on that schemas.
                     const numberOfElementsToRemove = (options.toInternalToBubbleUp?.length || 0) - startingToInternalBubbleUpLength;
                     options.toInternalToBubbleUp?.splice(startingToInternalBubbleUpLength, numberOfElementsToRemove);
                 }
@@ -31,7 +32,7 @@ export function unionValidation(schemas) {
             return {
                 parsed: parsedValues.parsed,
                 // eslint-disable-next-line ts/no-unnecessary-condition
-                errors: parsedValues.errors ? parsedValues.errors : []
+                errors: Array.isArray(parsedValues.errors) ? parsedValues.errors : []
             };
         }
     };

package/dist/esm/src/validators/utils.js

@@ -8,47 +8,61 @@ const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])
     return acc;
 }, {});
 /**
- * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list has lower priority validators on the end of the list and higher
- * priority validators on the start of the list. Maybe in the future we can change that to a binary tree, but for now this is enough.
+ * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list
+ * has lower priority validators on the end of the list and higher priority validators on the start of the
+ * list. Maybe in the future we can change that to a binary tree, but for now this is enough.
  *
- * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3 times on the schema in order to make the validation work. Each validator had
- * a different return type, i didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created this class. So pretty much, over here and
- * on each validator we can define the type it is. It can actually be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last, the `high` validators
- * are the ones that are going to be executed first. High validators validate if the value is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
+ * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3
+ * times on the schema in order to make the validation work. Each validator had  a different return type, i
+ * didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created
+ * this class. So pretty much, over here and on each validator we can define the type it is. It can actually
+ * be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last,
+ * The `high` validators are the ones that are going to be executed first. High validators validate if the value
+ * is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
  *
- * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number? No, right? So the high validator can stop the execution of the other validators.
- * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the `max` allowed 10? No, right? So the medium validator can stop the execution of
- * the other validators.
+ * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number?
+ * No, right? So the high validator can stop the execution of the other validators.
+ * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the
+ * `max` allowed 10? No, right? So the medium validator can stop the execution of the other validators.
  *
- * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also more powerful, because if we need to add any extra priorities we can do that easily
- * without changing the schema.
+ * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also
+ * more powerful, because if we need to add any extra priorities we can do that easily without changing the schema.
  */ export default class Validator {
     child;
     parent;
+    fallbackNamesAdded = new Set();
     priority;
     fallbacks = [];
     constructor(type){
+        this.fallbackNamesAdded = new Set();
+        this.fallbacks = [];
         this.priority = priorityByType[type];
     }
     /**
-   * We create all of the validators on the schema in order, i actually didn't want to go on that route but i found it easier to do so.
+   * We create all of the validators on the schema in order, i actually didn't want to go on that route but i
+   * found it easier to do so.
    *
-   * The logic here is simple, if it's not the same priority we will walk on the linked list until we find a validator that matches the priority we are expecting. If we can't walk anymore, we create
-   * the next priority validator and append it to the linked list. Be aware that it's a double linked list, so we can walk both ways, from the end to the start and from the start to the end.
-   * So you don't really need to start from the root, the linked list can start from anywhere and it will find it's way through.
+   * The logic here is simple, if it's not the same priority we will walk on the linked list until we find
+   * a validator that matches the priority we are expecting. If we can't walk anymore, we create the next
+   * priority validator and append it to the linked list. Be aware that it's a double linked list, so we
+   * can walk both ways, from the end to the start and from the start to the end.
+   * So you don't really need to start from the root, the linked list can start from anywhere and it will
+   * find it's way through.
    *
-   * I know there are better ways to do this instead of walking through the linked list, but like i explained before, this is enough for now.
+   * I know there are better ways to do this instead of walking through the linked list, but like i explained
+   * before, this is enough for now.
    *
-   * If the priority is higher than the current priority saved on the schema, we should substitute the rootValidator on the schema with the new one.
+   * If the priority is higher than the current priority saved on the schema, we should substitute the
+   * rootValidator on the schema with the new one.
    *
    * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema.
    * @param type - The type of the fallback that we are adding.
    * @param fallback - The fallback function that we are adding.
    * @param childOrParent - If we are adding a fallback to the child or to the parent.
    * @param options - The options that we are passing to the fallback.
-   */ checkAppendOrCreate(schema, type, fallback, childOrParent, options) {
+   */ checkAppendOrCreate(schema, type, fallbackName, fallback, childOrParent, options) {
         const schemaWithProtected = schema;
-        if (this[childOrParent]) this[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+        if (this[childOrParent]) this[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
         else {
             const nextPriority = childOrParent === 'child' ? this.priority - 1 : this.priority + 1;
             if (Object.keys(typeByPriority).includes(String(nextPriority))) {
@@ -56,24 +70,28 @@ const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])
                 const validatorInstance = new Validator(nextType);
                 this[childOrParent] = validatorInstance;
                 this[childOrParent][childOrParent === 'parent' ? 'child' : 'parent'] = this;
-                this[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+                this[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
                 if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority) schemaWithProtected.__rootFallbacksValidator = validatorInstance;
             }
         }
     }
-    addFallback(schema, type, fallback, options) {
+    addFallback(schema, type, fallbackName, fallback, options) {
+        if (this.fallbackNamesAdded.has(fallbackName) && options?.removeCurrent !== true) return;
+        this.fallbackNamesAdded.add(fallbackName);
         const priority = priorityByType[type];
         if (this.priority === priority) {
             if (typeof options?.at === 'number') this.fallbacks.splice(options.at, options.removeCurrent === true ? 1 : 0, fallback);
             else this.fallbacks.push(fallback);
-        } else if (priority > this.priority) this.checkAppendOrCreate(schema, type, fallback, 'parent', options);
-        else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallback, 'child', options);
+        } else if (priority > this.priority) this.checkAppendOrCreate(schema, type, fallbackName, fallback, 'parent', options);
+        else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallbackName, fallback, 'child', options);
     }
     /**
-   * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest priority to the lowest priority.
-   * A validator can stop the execution of the other validators if it feels like so. Like on the example of a value being null or undefined.
+   * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest
+   * priority to the lowest priority. A validator can stop the execution of the other validators if it feels
+   * like so. Like on the example of a value being null or undefined.
    *
-   * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is used to avoid duplicated errors.
+   * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is
+   * used to avoid duplicated errors.
    * @param path - The path that we are validating right now.
    * @param parseResult - The result of the parsing, it contains the parsed value and the errors that we found.
    * @param options - The options that we are passing to the fallback.
@@ -84,25 +102,33 @@ const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])
             parseResult.parsed = parsed;
             for (const error of errors){
                 if (error.isValid === false) {
-                    const hashedError = JSON.stringify(error);
+                    const sortedError = Object.fromEntries(Object.entries(error).sort(([a], [b])=>a.localeCompare(b)));
+                    const hashedError = JSON.stringify(sortedError);
                     if (errorsAsHashedSet.has(hashedError)) continue;
+                    errorsAsHashedSet.add(hashedError);
                     if (!Array.isArray(parseResult.errors)) parseResult.errors = [];
-                    parseResult.errors.push(error);
+                    parseResult.errors.push({
+                        ...error,
+                        received: parseResult.parsed
+                    });
                 }
             }
             doesItShouldPreventChildValidation = doesItShouldPreventChildValidation || preventChildValidation || false;
         }
-        if (this.child && doesItShouldPreventChildValidation === false) return this.child.validate(errorsAsHashedSet, path, parseResult, options);
+        if (this.child && doesItShouldPreventChildValidation === false) return await this.child.validate(errorsAsHashedSet, path, parseResult, options);
         return parseResult;
     }
     /**
-   * This static method takes care of everything for you. This means that you should only call this method for appending new fallbacks, it takes care of creating the root validator
-   * and making sure that the rootValidator on the schema is the highest priority one.
+   * This static method takes care of everything for you. This means that you should only call this method
+   * for appending new fallbacks, it takes care of creating the root validator and making sure that the
+   * rootValidator on the schema is the highest priority one.
    *
-   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema. We automatically define the rootValidator on the schema
-   * so you don't need to worry about that.
-   * @param fallback - The fallback that we are adding. This is an object that contains the type of the fallback and the callback that we are adding.
-   * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent` are passed to the `addFallback` method.
+   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific
+   * schema. We automatically define the rootValidator on the schema so you don't need to worry about that.
+   * @param fallback - The fallback that we are adding. This is an object that contains the type of the
+   * fallback and the callback that we are adding.
+   * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent`
+   * are passed to the `addFallback` method.
    */ static createAndAppendFallback(schema, fallback, options) {
         const schemaWithProtected = schema;
         let validatorInstance = schemaWithProtected.__rootFallbacksValidator;
@@ -111,7 +137,7 @@ const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])
             validatorInstance = new Validator(fallback.type);
             schemaWithProtected.__rootFallbacksValidator = validatorInstance;
         }
-        validatorInstance.addFallback(schema, fallback.type, fallback.callback, options);
+        validatorInstance.addFallback(schema, fallback.type, fallback.name, fallback.callback, options);
         return validatorInstance;
     }
     toString(ident = 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmares/schemas",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "This defines a default schema definition for validation of data, it abstract popular schema validation libraries like zod, yup, valibot and others\"",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -31,8 +31,8 @@
   },
   "homepage": "https://github.com/palmaresHQ/palmares#readme",
   "dependencies": {
-    "@palmares/databases": "0.0.2",
-    "@palmares/core": "0.0.4"
+    "@palmares/core": "0.1.0",
+    "@palmares/databases": "0.1.0"
   },
   "scripts": {
     "clear": "rimraf ./dist",

package/src/adapter/fields/array.ts

@@ -1,7 +1,7 @@
 import FieldAdapter from '.';
 
 import type WithFallback from '../../utils';
-import type { NumberAdapterTranslateArgs } from '../types';
+import type { ArrayAdapterTranslateArgs, NumberAdapterTranslateArgs } from '../types';
 
 export function arrayFieldAdapter<
   TTranslate extends ArrayFieldAdapter['translate'],
@@ -27,5 +27,5 @@ export function arrayFieldAdapter<
 }
 
 export default class ArrayFieldAdapter extends FieldAdapter {
-  translate(_fieldAdapter: FieldAdapter, _args: NumberAdapterTranslateArgs): any | WithFallback<'array'> {}
+  translate(_fieldAdapter: FieldAdapter, _args: ArrayAdapterTranslateArgs): any | WithFallback<'array'> {}
 }

package/src/adapter/fields/boolean.ts

@@ -10,12 +10,7 @@ export function booleanFieldAdapter<
   TToString extends BooleanFieldAdapter['toString'],
   TFormatError extends BooleanFieldAdapter['formatError'],
   TParse extends BooleanFieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomBooleanFieldAdapter extends BooleanFieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -29,8 +24,8 @@ export function booleanFieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 
 export default class BooleanFieldAdapter extends FieldAdapter {

package/src/adapter/fields/datetime.ts

@@ -5,18 +5,12 @@ import type SchemaAdapter from '..';
 import type WithFallback from '../../utils';
 import type { DatetimeAdapterTranslateArgs } from '../types';
 
-
 export function datetimeFieldAdapter<
   TTranslate extends DatetimeFieldAdapter['translate'],
   TToString extends DatetimeFieldAdapter['toString'],
   TFormatError extends DatetimeFieldAdapter['formatError'],
   TParse extends DatetimeFieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomDatetimeFieldAdapter extends DatetimeFieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -30,8 +24,8 @@ export function datetimeFieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 
 export default class DatetimeFieldAdapter extends FieldAdapter {

package/src/adapter/fields/index.ts

@@ -10,12 +10,7 @@ export function fieldAdapter<
   TToString extends FieldAdapter['toString'],
   TFormatError extends FieldAdapter['formatError'],
   TParse extends FieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomFieldAdapter extends FieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -29,20 +24,24 @@ export function fieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 export default class FieldAdapter {
-  translate(_fieldAdapter: FieldAdapter, _args: AdapterTranslateArgs<SupportedSchemas>, _base?: any): any | WithFallback<SupportedSchemas> {
+  translate(
+    _fieldAdapter: FieldAdapter,
+    _args: AdapterTranslateArgs<SupportedSchemas>,
+    _base?: any
+  ): any | WithFallback<SupportedSchemas> {
     throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'translate' });
   }
 
   parse(
     _adapter: SchemaAdapter,
     _fieldAdapter: FieldAdapter,
-    _result: any,
+    _schema: any,
     _value: any,
-    _args: Omit<AdapterTranslateArgs<SupportedSchemas>, 'withFallback'>,
+    _args: Omit<AdapterTranslateArgs<SupportedSchemas>, 'withFallback'>
   ): Promise<{ errors: any; parsed: any }> {
     throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
   }
@@ -60,6 +59,7 @@ export default class FieldAdapter {
   async formatError(
     _adapter: SchemaAdapter,
     _fieldAdapter: FieldAdapter,
+    _schema: any,
     _error: any,
     _metadata?: any
   ): Promise<{

package/src/adapter/fields/number.ts

@@ -5,18 +5,12 @@ import type SchemaAdapter from '..';
 import type WithFallback from '../../utils';
 import type { NumberAdapterTranslateArgs } from '../types';
 
-
 export function numberFieldAdapter<
   TTranslate extends NumberFieldAdapter['translate'],
   TToString extends NumberFieldAdapter['toString'],
   TFormatError extends NumberFieldAdapter['formatError'],
   TParse extends NumberFieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomNumberFieldAdapter extends NumberFieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -30,8 +24,8 @@ export function numberFieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 
 export default class NumberFieldAdapter extends FieldAdapter {

package/src/adapter/fields/object.ts

@@ -3,20 +3,14 @@ import { SchemaAdapterNotImplementedError } from '../../exceptions';
 
 import type SchemaAdapter from '..';
 import type WithFallback from '../../utils';
-import type { ObjectAdapterTranslateArgs } from '../types';
-
+import type { ObjectAdapterToStringArgs, ObjectAdapterTranslateArgs } from '../types';
 
 export function objectFieldAdapter<
   TTranslate extends ObjectFieldAdapter['translate'],
   TToString extends ObjectFieldAdapter['toString'],
   TFormatError extends ObjectFieldAdapter['formatError'],
   TParse extends ObjectFieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomObjectFieldAdapter extends ObjectFieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -30,8 +24,8 @@ export function objectFieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 
 export default class ObjectFieldAdapter extends FieldAdapter {
@@ -46,4 +40,13 @@ export default class ObjectFieldAdapter extends FieldAdapter {
   ): Promise<{ errors: any; parsed: any }> {
     throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
   }
+
+  toString(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _args: ObjectAdapterToStringArgs,
+    _base?: any
+  ): Promise<string> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'toString' });
+  }
 }

package/src/adapter/fields/string.ts

@@ -5,18 +5,12 @@ import type SchemaAdapter from '..';
 import type WithFallback from '../../utils';
 import type { StringAdapterTranslateArgs } from '../types';
 
-
 export function stringFieldAdapter<
   TTranslate extends StringFieldAdapter['translate'],
   TToString extends StringFieldAdapter['toString'],
   TFormatError extends StringFieldAdapter['formatError'],
   TParse extends StringFieldAdapter['parse']
->(args: {
-  translate: TTranslate;
-  toString?: TToString;
-  formatError?: TFormatError;
-  parse?: TParse;
-}) {
+>(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
   class CustomStringFieldAdapter extends StringFieldAdapter {
     translate = args.translate;
     toString = args.toString as TToString;
@@ -30,8 +24,8 @@ export function stringFieldAdapter<
       toString: TToString;
       formatError: TFormatError;
       parse: TParse;
-    }
-  }
+    };
+  };
 }
 
 export default class StringFieldAdapter extends FieldAdapter {