@palmares/schemas 0.0.1 → 0.1.1

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

@@ -17,7 +17,6 @@ _export(exports, {
     }
 });
 var _schema = /*#__PURE__*/ _interop_require_default(require("./schema"));
-var _conf = require("../conf");
 var _utils = require("../utils");
 var _object = require("../validators/object");
 var _utils1 = /*#__PURE__*/ _interop_require_default(require("../validators/utils"));
@@ -349,6 +348,12 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
         _this = _super.call(this);
         _define_property(_assert_this_initialized(_this), "__data", void 0);
         _define_property(_assert_this_initialized(_this), "__cachedDataAsEntries", void 0);
+        _define_property(_assert_this_initialized(_this), "__type", {
+            message: 'Invalid type',
+            check: function(value) {
+                return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null;
+            }
+        });
         _this.__data = data;
         return _this;
     }
@@ -468,6 +473,7 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
                                                                 data: isStringVersion ? asString : transformed,
                                                                 nullable: _this.__nullable,
                                                                 optional: _this.__optional,
+                                                                type: _this.__type,
                                                                 parsers: {
                                                                     nullable: _this.__nullable.allow,
                                                                     optional: _this.__optional.allow
@@ -489,7 +495,7 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
                                 return function(adapter) {
                                     return _ref.apply(this, arguments);
                                 };
-                            }(), _this.__transformedSchemas, options, 'object')
+                            }(), _this, _this.__transformedSchemas, options, 'object')
                         ];
                     });
                 })();
@@ -498,8 +504,10 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
         {
             key: "data",
             value: /**
-   * Transform the data to the representation without validating it. This is useful when you want to return a data from a query directly to the user. The core idea of this is that you can join the data
-   * from the database "by hand". In other words, you can do the joins by yourself directly on code. For more complex cases, this can be really helpful.
+   * Transform the data to the representation without validating it. This is useful when you want to return a data
+   * from a query directly to the user. The core idea of this is that you can join the data from the database "by hand".
+   * In other words, you can do the joins by yourself directly on code. For more complex cases, this can be really
+   * helpful.
    *
    * @param value - The value to be transformed.
    *
@@ -575,7 +583,8 @@ var ObjectSchema = /*#__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
@@ -587,7 +596,8 @@ var ObjectSchema = /*#__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.
@@ -600,9 +610,10 @@ var ObjectSchema = /*#__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
@@ -630,8 +641,11 @@ var ObjectSchema = /*#__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.
@@ -642,7 +656,28 @@ var ObjectSchema = /*#__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
+   * 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(ObjectSchema.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
@@ -672,14 +707,37 @@ var ObjectSchema = /*#__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(ObjectSchema.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
@@ -701,9 +759,12 @@ var ObjectSchema = /*#__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",
@@ -713,9 +774,9 @@ var ObjectSchema = /*#__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.
    *
@@ -760,7 +821,8 @@ var ObjectSchema = /*#__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
@@ -779,8 +841,9 @@ var ObjectSchema = /*#__PURE__*/ function(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.
+   * 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
@@ -792,12 +855,13 @@ var ObjectSchema = /*#__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",
@@ -807,8 +871,9 @@ var ObjectSchema = /*#__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
@@ -847,8 +912,10 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
    * ```
    * @param toRepresentationCallback - The callback that will be called to transform the value to the representation.
    * @param options - Options for the toRepresentation function.
-   * @param options.after - Whether the toRepresentationCallback should be called after the existing toRepresentationCallback. Defaults to true.
-   * @param options.before - Whether the toRepresentationCallback should be called before the existing toRepresentationCallback. Defaults to true.
+   * @param options.after - Whether the toRepresentationCallback should be called after the existing
+   * toRepresentationCallback. Defaults to true.
+   * @param options.before - Whether the toRepresentationCallback should be called before the existing
+   * toRepresentationCallback. Defaults to true.
    *
    * @returns The schema with a new return type
    */ key: "toRepresentation",
@@ -858,8 +925,9 @@ var ObjectSchema = /*#__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
@@ -895,8 +963,9 @@ var ObjectSchema = /*#__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
    * ```
@@ -984,12 +1053,6 @@ var ObjectSchema = /*#__PURE__*/ function(Schema) {
             key: "new",
             value: function _new(data) {
                 var returnValue = new ObjectSchema(data);
-                var adapterInstance = (0, _conf.getDefaultAdapter)();
-                returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
-                    transformed: false,
-                    adapter: adapterInstance,
-                    schemas: []
-                };
                 return returnValue;
             }
         }