@palmares/schemas 0.0.1 → 0.1.1

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

@@ -17,7 +17,6 @@ _export(exports, {
     }
 });
 var _schema = /*#__PURE__*/ _interop_require_default(require("./schema"));
-var _conf = require("../conf");
 var _utils = require("../utils");
 var _array = require("../validators/array");
 var _schema1 = require("../validators/schema");
@@ -360,6 +359,12 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         var _this;
         _this = _super.call(this);
         _define_property(_assert_this_initialized(_this), "__schemas", void 0);
+        _define_property(_assert_this_initialized(_this), "__type", {
+            message: 'Invalid type',
+            check: function(value) {
+                return Array.isArray(value);
+            }
+        });
         _define_property(_assert_this_initialized(_this), "__minLength", void 0);
         _define_property(_assert_this_initialized(_this), "__maxLength", void 0);
         _define_property(_assert_this_initialized(_this), "__nonEmpty", void 0);
@@ -449,6 +454,8 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
                                                             maxLength: _this.__maxLength,
                                                             minLength: _this.__minLength,
                                                             nonEmpty: _this.__nonEmpty,
+                                                            schemas: transformedSchemas,
+                                                            type: _this.__type,
                                                             parsers: {
                                                                 nullable: _this.__nullable.allow,
                                                                 optional: _this.__optional.allow
@@ -479,7 +486,7 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
                                 return function(adapter) {
                                     return _ref.apply(this, arguments);
                                 };
-                            }(), _this.__transformedSchemas, options, 'array')
+                            }(), _this, _this.__transformedSchemas, options, 'array')
                         ];
                     });
                 })();
@@ -487,7 +494,8 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
@@ -499,7 +507,8 @@ var ArraySchema = /*#__PURE__*/ function(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.
@@ -512,9 +521,10 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
@@ -541,8 +551,10 @@ var ArraySchema = /*#__PURE__*/ function(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.
@@ -553,8 +565,28 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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.
+   */ key: "nonOptional",
+            value: function nonOptional(options) {
+                return _get(_get_prototype_of(ArraySchema.prototype), "optional", this).call(this, {
+                    message: options === null || options === void 0 ? void 0 : 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
@@ -583,14 +615,35 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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.
+   */ key: "nonNullable",
+            value: function nonNullable(options) {
+                return _get(_get_prototype_of(ArraySchema.prototype), "nullable", this).call(this, {
+                    message: (options === null || options === void 0 ? void 0 : 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
@@ -612,9 +665,12 @@ var ArraySchema = /*#__PURE__*/ function(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.
    */ key: "omit",
@@ -624,9 +680,9 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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.
    *
@@ -671,7 +727,8 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
@@ -688,10 +745,94 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
                 return _get(_get_prototype_of(ArraySchema.prototype), "default", this).call(this, defaultValueOrFunction);
             }
         },
+        {
+            key: "data",
+            value: /**
+   * 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'
+   * });
+   * ```
+   */ function data(value) {
+                var _this = this;
+                var _this1 = this, _superprop_get_data = function() {
+                    return _get(_get_prototype_of(ArraySchema.prototype), "data", _this);
+                };
+                return _async_to_generator(function() {
+                    var parsedValue;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _superprop_get_data().call(_this1, value)
+                                ];
+                            case 1:
+                                parsedValue = _state.sent();
+                                if (!Array.isArray(parsedValue)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    Promise.all(Array.isArray(_this1.__schemas[0]) ? parsedValue.map(function(value) {
+                                        var schema = _this1.__schemas[0][0];
+                                        return (0, _utils.shouldRunDataOnComplexSchemas)(schema) ? schema.data(value) : value;
+                                    }) : _this1.__schemas.map(function() {
+                                        var _ref = _async_to_generator(function(schema) {
+                                            return _ts_generator(this, function(_state) {
+                                                return [
+                                                    2,
+                                                    (0, _utils.shouldRunDataOnComplexSchemas)(schema) ? schema.data(value) : value
+                                                ];
+                                            });
+                                        });
+                                        return function(schema) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 2:
+                                parsedValue = _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    2,
+                                    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.
+   * 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
@@ -703,12 +844,13 @@ var ArraySchema = /*#__PURE__*/ function(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.
    */ key: "extends",
@@ -718,8 +860,9 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
@@ -766,8 +909,9 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
@@ -803,8 +947,9 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             /**
-   * 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
    * ```
@@ -828,12 +973,11 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             key: "minLength",
-            value: function minLength(value) {
-                var inclusive = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, message = arguments.length > 2 ? arguments[2] : void 0;
-                message = message || "The array must have a minimum length of ".concat(value);
+            value: function minLength(value, options) {
+                var message = (options === null || options === void 0 ? void 0 : options.message) || "The array must have a minimum length of ".concat(value);
                 this.__minLength = {
                     value: value,
-                    inclusive: inclusive,
+                    inclusive: typeof (options === null || options === void 0 ? void 0 : options.inclusive) === 'boolean' ? options.inclusive : true,
                     message: message
                 };
                 return this;
@@ -841,22 +985,11 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
         },
         {
             key: "maxLength",
-            value: function maxLength(value) {
-                var inclusive = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, message = arguments.length > 2 ? arguments[2] : void 0;
-                message = message || "The array must have a maximum length of ".concat(value);
+            value: function maxLength(value, options) {
+                var message = (options === null || options === void 0 ? void 0 : options.message) || "The array must have a maximum length of ".concat(value);
                 this.__maxLength = {
                     value: value,
-                    inclusive: inclusive,
-                    message: message
-                };
-                return this;
-            }
-        },
-        {
-            key: "nonEmpty",
-            value: function nonEmpty(message) {
-                message = message || 'The array must not be empty';
-                this.__nonEmpty = {
+                    inclusive: typeof (options === null || options === void 0 ? void 0 : options.inclusive) === 'boolean' ? options.inclusive : true,
                     message: message
                 };
                 return this;
@@ -870,12 +1003,6 @@ var ArraySchema = /*#__PURE__*/ function(Schema) {
                     schemas[_key] = arguments[_key];
                 }
                 var returnValue = _construct(ArraySchema, _to_consumable_array(schemas));
-                var adapterInstance = (0, _conf.getDefaultAdapter)();
-                returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
-                    transformed: false,
-                    adapter: adapterInstance,
-                    schemas: []
-                };
                 return returnValue;
             }
         }