@palmares/schemas 0.0.1 → 0.1.0

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

@@ -1,11 +1,14 @@
 import Schema from './schema';
-import { getDefaultAdapter } from '../conf';
-import { defaultTransform, defaultTransformToAdapter, transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas } from '../utils';
+import { defaultTransform, defaultTransformToAdapter, shouldRunDataOnComplexSchemas, transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas } from '../utils';
 import { arrayValidation, maxLength, minLength, nonEmpty } from '../validators/array';
 import { nullable, optional } from '../validators/schema';
 import Validator from '../validators/utils';
 export default class ArraySchema extends Schema {
     __schemas;
+    __type = {
+        message: 'Invalid type',
+        check: (value)=>Array.isArray(value)
+    };
     __minLength;
     __maxLength;
     __nonEmpty;
@@ -36,6 +39,8 @@ export default class ArraySchema extends Schema {
                     maxLength: this.__maxLength,
                     minLength: this.__minLength,
                     nonEmpty: this.__nonEmpty,
+                    schemas: transformedSchemas,
+                    type: this.__type,
                     parsers: {
                         nullable: this.__nullable.allow,
                         optional: this.__optional.allow
@@ -51,10 +56,11 @@ export default class ArraySchema extends Schema {
                 // eslint-disable-next-line ts/require-await
                 fallbackIfNotSupported: async ()=>[]
             });
-        }, this.__transformedSchemas, options, 'array');
+        }, this, this.__transformedSchemas, options, 'array');
     }
     /**
-   * This let's you refine the schema with custom validations. This is useful when you want to validate something that is not supported by default by the schema adapter.
+   * This let's you refine the schema with custom validations. This is useful when you want to validate something that
+   * is not supported by default by the schema adapter.
    *
    * @example
    * ```typescript
@@ -66,7 +72,8 @@ export default class ArraySchema extends Schema {
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
    *
-   * console.log(errors); // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   *  // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param refinementCallback - The callback that will be called to validate the value.
@@ -76,9 +83,10 @@ export default class ArraySchema extends Schema {
         return super.refine(refinementCallback);
     }
     /**
-   * Allows the value to be either undefined or null. Different from the `optional` method on other schemas, You can pass `outputOnly` as `true` to this method.
-   * This will allow you to pass `null` or `undefined` as a value on the {@link Schema.data} method, but it will not allow the value to be `null` or `undefined`.
-   * This is useful for typing purposes.
+   * Allows the value to be either undefined or null. Different from the `optional` method on other schemas, You can
+   * pass `outputOnly` as `true` to this method.
+   * This will allow you to pass `null` or `undefined` as a value on the {@link Schema.data} method, but it will not
+   * allow the value to be `null` or `undefined`. This is useful for typing purposes.
    *
    * @example
    * ```typescript
@@ -105,8 +113,10 @@ export default class ArraySchema extends Schema {
    *   company: companySchema.optional({ outputOnly: true })
    * });
    *
-   * const { errors, parsed } = await userSchema.data({ id: 1, name: 'John Doe' }); // Will not allow the company to be null or undefined on a typing level.
-   * const value = await userSchema.data({ id: 1, name: 'John Doe' }); // Will allow the company to be null or undefined on a typing level
+   * // Will not allow the company to be null or undefined on a typing level.
+   * const { errors, parsed } = await userSchema.data({ id: 1, name: 'John Doe' });
+   * // Will allow the company to be null or undefined on a typing level
+   * const value = await userSchema.data({ id: 1, name: 'John Doe' });
    * ```
    *
    * @returns - The schema we are working with.
@@ -114,8 +124,25 @@ export default class ArraySchema extends Schema {
         return options?.outputOnly ? this : super.optional(options);
     }
     /**
-   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value is NULL by setting
-   * the { message: 'Your custom message', allow: false } on the options.
+   * Just adds a message when the value is undefined. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.datetime().optional({ message: 'This value should be defined', allow: false })
+   * ```
+   *
+   * @param options - The options of nonOptional function
+   * @param options.message - A custom message if the value is undefined.
+   *
+   * @returns - The schema.
+   */ nonOptional(options) {
+        return super.optional({
+            message: options?.message,
+            allow: false
+        });
+    }
+    /**
+   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value
+   * is NULL by setting the { message: 'Your custom message', allow: false } on the options.
    *
    * @example
    * ```typescript
@@ -141,14 +168,32 @@ export default class ArraySchema extends Schema {
         return super.nullable(options);
     }
     /**
-   * This method will remove the value from the representation of the schema. If the value is undefined it will keep that way
-   * otherwise it will set the value to undefined after it's validated.
+   * Just adds a message when the value is null. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.datetime().nullable({ message: 'This value cannot be null', allow: false })
+   * ```
+   *
+   * @param options - The options of nonNullable function
+   * @param options.message - A custom message if the value is null.
+   *
+   * @returns - The schema.
+   */ nonNullable(options) {
+        return super.nullable({
+            message: options?.message || '',
+            allow: false
+        });
+    }
+    /**
+   * This method will remove the value from the representation of the schema. If the value is undefined it will keep
+   * that way otherwise it will set the value to undefined after it's validated.
    * This is used in conjunction with the {@link data} function, the {@link parse} function or {@link validate}
    * function. This will remove the value from the representation of the schema.
    *
-   * By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * By default, the value will be removed just from the representation, in other words, when you call the {@link data}
+   * function. But if you want to remove the value from the internal representation, you can pass the argument
+   * `toInternal` as true. Then if you still want to remove the value from the representation, you will need to pass
+   * the argument `toRepresentation` as true as well.
    *
    * @example
    * ```typescript
@@ -170,18 +215,21 @@ export default class ArraySchema extends Schema {
    * ```
    *
    *
-   * @param args - By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * @param args - By default, the value will be removed just from the representation, in other words, when you call
+   * the {@link data} function.
+   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal`
+   * as true.
+   * Then if you still want to remove the value from the representation, you will need to pass the argument
+   * `toRepresentation` as true as well.
    *
    * @returns The schema.
    */ omit(args) {
         return super.omit(args);
     }
     /**
-   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external source
-   * like a database. You should always return the schema after you save the value, that way we will always have the correct type
-   * of the schema after the save operation.
+   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external
+   * source like a database. You should always return the schema after you save the value, that way we will always have
+   * the correct type of the schema after the save operation.
    *
    * You can use the {@link toRepresentation} function to transform and clean the value it returns after the save.
    *
@@ -223,7 +271,8 @@ export default class ArraySchema extends Schema {
         return super.onSave(callback);
     }
     /**
-   * This function is used to add a default value to the schema. If the value is either undefined or null, the default value will be used.
+   * This function is used to add a default value to the schema. If the value is either undefined or null, the default
+   * value will be used.
    *
    * @example
    * ```typescript
@@ -239,8 +288,50 @@ export default class ArraySchema extends Schema {
         return super.default(defaultValueOrFunction);
     }
     /**
-   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call this function to let you customize
-   * the custom schema your own way. Our API does not support passthrough? No problem, you can use this function to customize the zod schema.
+   * This function is used to transform the value to the representation without validating it.
+   * This is useful when you want to return a data from a query directly to the user. But for example
+   * you are returning the data of a user, you can clean the password or any other sensitive data.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const userSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   *   email: p.string().email(),
+   *   password: p.string().optional()
+   * }).toRepresentation(async (value) => {
+   *   return {
+   *    id: value.id,
+   *    name: value.name,
+   *   email: value.email
+   *  }
+   * });
+   *
+   * const user = await userSchema.data({
+   *   id: 1,
+   *   name: 'John Doe',
+   *   email: 'john@gmail.com',
+   *   password: '123456'
+   * });
+   * ```
+   */ async data(value) {
+        let parsedValue = await super.data(value);
+        if (Array.isArray(parsedValue)) {
+            parsedValue = await Promise.all(Array.isArray(this.__schemas[0]) ? parsedValue.map((value)=>{
+                const schema = this.__schemas[0][0];
+                return shouldRunDataOnComplexSchemas(schema) ? schema.data(value) : value;
+            }) : this.__schemas.map(async (schema)=>{
+                return shouldRunDataOnComplexSchemas(schema) ? schema.data(value) : value;
+            }));
+        }
+        return parsedValue;
+    }
+    /**
+   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call
+   * this function to let you customize the custom schema your own way. Our API does not support passthrough?
+   * No problem, you can use this function to customize the zod schema.
    *
    * @example
    * ```typescript
@@ -252,20 +343,22 @@ export default class ArraySchema extends Schema {
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
    *
-   * console.log(errors); // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param callback - The callback that will be called to customize the schema.
-   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to compile the underlying schema
-   * to a string so you can save it for future runs.
+   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to
+   * compile the underlying schema to a string so you can save it for future runs.
    *
    * @returns The schema.
    */ extends(callback, toStringCallback) {
         return super.extends(callback, toStringCallback);
     }
     /**
-   * This function is used to transform the value to the representation of the schema. When using the {@link data} function. With this function you have full
-   * control to add data cleaning for example, transforming the data and whatever. Another use case is when you want to return deeply nested recursive data.
+   * This function is used to transform the value to the representation of the schema. When using the {@link data}
+   * function. With this function you have full control to add data cleaning for example, transforming the data and
+   * whatever. Another use case is when you want to return deeply nested recursive data.
    * The schema maps to itself.
    *
    * @example
@@ -309,8 +402,9 @@ export default class ArraySchema extends Schema {
         return super.toRepresentation(toRepresentationCallback);
     }
     /**
-   * This function is used to transform the value to the internal representation of the schema. This is useful when you want to transform the value
-   * to a type that the schema adapter can understand. For example, you might want to transform a string to a date. This is the function you use.
+   * This function is used to transform the value to the internal representation of the schema. This is useful when you
+   * want to transform the value to a type that the schema adapter can understand. For example, you might want to
+   * transform a string to a date. This is the function you use.
    *
    * @example
    * ```typescript
@@ -343,8 +437,9 @@ export default class ArraySchema extends Schema {
         return super.toInternal(toInternalCallback);
     }
     /**
-   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string, you can convert that string to a date
-   * here BEFORE the validation. This pretty much transforms the value to a type that the schema adapter can understand.
+   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string,
+   * you can convert that string to a date here BEFORE the validation. This pretty much transforms the value to a type
+   * that the schema adapter can understand.
    *
    * @example
    * ```
@@ -364,39 +459,26 @@ export default class ArraySchema extends Schema {
    */ toValidate(toValidateCallback) {
         return super.toValidate(toValidateCallback);
     }
-    minLength(value, inclusive = true, message) {
-        message = message || `The array must have a minimum length of ${value}`;
+    minLength(value, options) {
+        const message = options?.message || `The array must have a minimum length of ${value}`;
         this.__minLength = {
             value: value,
-            inclusive: inclusive,
+            inclusive: typeof options?.inclusive === 'boolean' ? options.inclusive : true,
             message: message
         };
         return this;
     }
-    maxLength(value, inclusive = true, message) {
-        message = message || `The array must have a maximum length of ${value}`;
+    maxLength(value, options) {
+        const message = options?.message || `The array must have a maximum length of ${value}`;
         this.__maxLength = {
             value: value,
-            inclusive: inclusive,
-            message: message
-        };
-        return this;
-    }
-    nonEmpty(message) {
-        message = message || 'The array must not be empty';
-        this.__nonEmpty = {
+            inclusive: typeof options?.inclusive === 'boolean' ? options.inclusive : true,
             message: message
         };
         return this;
     }
     static new(...schemas) {
         const returnValue = new ArraySchema(...schemas);
-        const adapterInstance = getDefaultAdapter();
-        returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
-            transformed: false,
-            adapter: adapterInstance,
-            schemas: []
-        };
         return returnValue;
     }
 }

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

@@ -1,5 +1,4 @@
 import Schema from './schema';
-import { getDefaultAdapter } from '../conf';
 import convertFromStringBuilder from '../parsers/convert-from-string';
 import { defaultTransform, defaultTransformToAdapter } from '../utils';
 import { booleanValidation } from '../validators/boolean';
@@ -10,18 +9,30 @@ export default class BooleanSchema extends Schema {
     __trueValues;
     __falseValues;
     __is;
+    __type = {
+        message: 'Invalid type',
+        check: (value)=>{
+            if (typeof value === 'string' && this.__allowString) return true;
+            if (typeof value === 'number' && this.__allowNumber) return true;
+            if (Array.isArray(this.__trueValues) && this.__trueValues.includes(value)) return true;
+            if (Array.isArray(this.__falseValues) && this.__falseValues.includes(value)) return true;
+            return typeof value === 'boolean';
+        }
+    };
     async __transformToAdapter(options) {
         return defaultTransformToAdapter(async (adapter)=>{
             return defaultTransform('boolean', this, adapter, adapter.boolean, ()=>({
                     parsers: {
                         allowString: this.__allowString,
                         allowNumber: this.__allowNumber,
-                        is: this.__is.value,
+                        // eslint-disable-next-line ts/no-unnecessary-condition
+                        is: this.__is?.value,
                         trueValues: this.__trueValues,
                         falseValues: this.__falseValues,
                         nullable: this.__nullable.allow,
                         optional: this.__optional.allow
                     },
+                    type: this.__type,
                     is: this.__is,
                     nullable: this.__nullable,
                     optional: this.__optional
@@ -35,10 +46,11 @@ export default class BooleanSchema extends Schema {
                 // eslint-disable-next-line ts/require-await
                 fallbackIfNotSupported: async ()=>[]
             });
-        }, this.__transformedSchemas, options, 'boolean');
+        }, this, this.__transformedSchemas, options, 'boolean');
     }
     /**
-   * This let's you refine the schema with custom validations. This is useful when you want to validate something that is not supported by default by the schema adapter.
+   * This let's you refine the schema with custom validations. This is useful when you want to validate something that
+   * is not supported by default by the schema adapter.
    *
    * @example
    * ```typescript
@@ -50,7 +62,8 @@ export default class BooleanSchema extends Schema {
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
    *
-   * console.log(errors); // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param refinementCallback - The callback that will be called to validate the value.
@@ -88,8 +101,25 @@ export default class BooleanSchema extends Schema {
         return super.optional(options);
     }
     /**
-   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value is NULL by setting
-   * the { message: 'Your custom message', allow: false } on the options.
+   * Just adds a message when the value is undefined. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.string().optional({ message: 'This value cannot be null', allow: false })
+   * ```
+   *
+   * @param options - The options of nonOptional function
+   * @param options.message - A custom message if the value is undefined.
+   *
+   * @returns - The schema.
+   */ nonOptional(options) {
+        return super.optional({
+            message: options?.message,
+            allow: false
+        });
+    }
+    /**
+   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value is
+   * NULL by setting the { message: 'Your custom message', allow: false } on the options.
    *
    * @example
    * ```typescript
@@ -115,14 +145,32 @@ export default class BooleanSchema extends Schema {
         return super.nullable(options);
     }
     /**
-   * This method will remove the value from the representation of the schema. If the value is undefined it will keep that way
-   * otherwise it will set the value to undefined after it's validated.
+   * Just adds a message when the value is null. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.string().nullable({ message: 'This value cannot be null', allow: false })
+   * ```
+   *
+   * @param options - The options of nonNullable function
+   * @param options.message - A custom message if the value is null.
+   *
+   * @returns - The schema.
+   */ nonNullable(options) {
+        return super.nullable({
+            message: options?.message || '',
+            allow: false
+        });
+    }
+    /**
+   * This method will remove the value from the representation of the schema. If the value is undefined it will keep
+   * that way otherwise it will set the value to undefined after it's validated.
    * This is used in conjunction with the {@link data} function, the {@link parse} function or {@link validate}
    * function. This will remove the value from the representation of the schema.
    *
-   * By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * By default, the value will be removed just from the representation, in other words, when you call the {@link data}
+   * function.But if you want to remove the value from the internal representation, you can pass the argument
+   * `toInternal` as true. Then if you still want to remove the value from the representation, you will need to pass
+   * the argument `toRepresentation` as true as well.
    *
    * @example
    * ```typescript
@@ -144,18 +192,20 @@ export default class BooleanSchema extends Schema {
    * ```
    *
    *
-   * @param args - By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * @param args - By default, the value will be removed just from the representation, in other words, when you call
+   * the {@link data} function. But if you want to remove the value from the internal representation, you can pass the
+   * argument `toInternal` as true.
+   * Then if you still want to remove the value from the representation, you will need to pass the argument
+   * `toRepresentation` as true as well.
    *
    * @returns The schema.
    */ omit(args) {
         return super.omit(args);
     }
     /**
-   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external source
-   * like a database. You should always return the schema after you save the value, that way we will always have the correct type
-   * of the schema after the save operation.
+   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external
+   * source like a database. You should always return the schema after you save the value, that way we will always have
+   * the correct type of the schema after the save operation.
    *
    * You can use the {@link toRepresentation} function to transform and clean the value it returns after the save.
    *
@@ -197,7 +247,8 @@ export default class BooleanSchema extends Schema {
         return super.onSave(callback);
     }
     /**
-   * This function is used to add a default value to the schema. If the value is either undefined or null, the default value will be used.
+   * This function is used to add a default value to the schema. If the value is either undefined or null, the default
+   * value will be used.
    *
    * @example
    * ```typescript
@@ -213,8 +264,9 @@ export default class BooleanSchema extends Schema {
         return super.default(defaultValueOrFunction);
     }
     /**
-   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call this function to let you customize
-   * the custom schema your own way. Our API does not support passthrough? No problem, you can use this function to customize the zod schema.
+   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call
+   * this function to let you customize the custom schema your own way. Our API does not support passthrough?
+   * No problem, you can use this function to customize the zod schema.
    *
    * @example
    * ```typescript
@@ -225,22 +277,22 @@ export default class BooleanSchema extends Schema {
    * });
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
-   *
-   * console.log(errors); // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param callback - The callback that will be called to customize the schema.
-   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to compile the underlying schema
-   * to a string so you can save it for future runs.
+   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to
+   * compile the underlying schema to a string so you can save it for future runs.
    *
    * @returns The schema.
    */ extends(callback, toStringCallback) {
         return super.extends(callback, toStringCallback);
     }
     /**
-   * This function is used to transform the value to the representation of the schema. When using the {@link data} function. With this function you have full
-   * control to add data cleaning for example, transforming the data and whatever. Another use case is when you want to return deeply nested recursive data.
-   * The schema maps to itself.
+   * This function is used to transform the value to the representation of the schema. When using the {@link data}
+   * function. With this function you have full control to add data cleaning for example, transforming the data and
+   * whatever. Another use case is when you want to return deeply nested recursive data. The schema maps to itself.
    *
    * @example
    * ```typescript
@@ -283,8 +335,9 @@ export default class BooleanSchema extends Schema {
         return super.toRepresentation(toRepresentationCallback);
     }
     /**
-   * This function is used to transform the value to the internal representation of the schema. This is useful when you want to transform the value
-   * to a type that the schema adapter can understand. For example, you might want to transform a string to a date. This is the function you use.
+   * This function is used to transform the value to the internal representation of the schema. This is useful when
+   * you want to transform the value to a type that the schema adapter can understand. For example, you might want
+   * to transform a string to a date. This is the function you use.
    *
    * @example
    * ```typescript
@@ -317,8 +370,9 @@ export default class BooleanSchema extends Schema {
         return super.toInternal(toInternalCallback);
     }
     /**
-   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string, you can convert that string to a date
-   * here BEFORE the validation. This pretty much transforms the value to a type that the schema adapter can understand.
+   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string,
+   * you can convert that string to a date here BEFORE the validation. This pretty much transforms the value to a type
+   * that the schema adapter can understand.
    *
    * @example
    * ```
@@ -339,7 +393,8 @@ export default class BooleanSchema extends Schema {
         return super.toValidate(toValidateCallback);
     }
     /**
-   * This will allow the value to be a string, it does not validate, it just parses inputs as strings and allows the result to be a string as well.
+   * This will allow the value to be a string, it does not validate, it just parses inputs as strings and allows the
+   * result to be a string as well.
    *
    * @example
    * ```ts
@@ -358,7 +413,8 @@ export default class BooleanSchema extends Schema {
         return this;
     }
     /**
-   * Allows you to set the values that will be considered as true. This is useful when you have a string that can be 'T' or 'F' for example.
+   * Allows you to set the values that will be considered as true. This is useful when you have a string that can be
+   * 'T' or 'F' for example.
    *
    * @example
    * ```ts
@@ -373,15 +429,17 @@ export default class BooleanSchema extends Schema {
         this.__trueValues = values;
         this.__parsers.medium.set('trueValues', (value)=>{
             const valueExistsInList = values.includes(value);
+            console.log('trueValues', valueExistsInList);
             return {
                 preventNextParsers: valueExistsInList,
-                value: valueExistsInList
+                value: valueExistsInList ? true : value
             };
         });
         return this;
     }
     /**
-   * Allows you to set the values that will be considered as false. This is useful when you have a string that can be 'N' or 0 for example.
+   * Allows you to set the values that will be considered as false. This is useful when you have a string that can
+   * be 'N' or 0 for example.
    *
    * @example
    * ```ts
@@ -396,15 +454,17 @@ export default class BooleanSchema extends Schema {
         this.__falseValues = values;
         this.__parsers.medium.set('falseValues', (value)=>{
             const valueExistsInList = values.includes(value);
+            console.log('falseValues', valueExistsInList);
             return {
                 preventNextParsers: valueExistsInList,
-                value: !valueExistsInList
+                value: valueExistsInList ? false : value
             };
         });
         return this;
     }
     /**
-   * This will allow the value to be a number, it does not validate, it just parses inputs as number and allows the result to be a string as well.
+   * This will allow the value to be a number, it does not validate, it just parses inputs as number and allows the
+   * result to be a string as well.
    *
    * @example
    * ```ts
@@ -453,12 +513,6 @@ export default class BooleanSchema extends Schema {
     }
     static new() {
         const returnValue = new BooleanSchema();
-        const adapterInstance = getDefaultAdapter();
-        returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
-            transformed: false,
-            adapter: adapterInstance,
-            schemas: []
-        };
         return returnValue;
     }
 }