@palmares/schemas 0.0.1 → 0.1.0

package/src/validators/number.ts

@@ -4,9 +4,14 @@ import type { ValidationFallbackReturnType } from '../schema/types';
 
 export function numberValidation(): ValidationFallbackReturnType {
   return {
+    name: 'number',
     type: 'medium',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       return {
         parsed: value,
         errors: [
@@ -15,19 +20,24 @@ export function numberValidation(): ValidationFallbackReturnType {
             code: 'number',
             // eslint-disable-next-line ts/no-unnecessary-condition
             path: path || [],
-            message: 'The value must be a number. Received: ' + typeof value,
-          },
-        ],
+            message: 'The value must be a number. Received: ' + typeof value
+          }
+        ]
       };
-    },
+    }
   };
 }
 
-export function max(args: NumberSchema['__max']): ValidationFallbackReturnType {
+export function max(args: NonNullable<NumberSchema['__max']>): ValidationFallbackReturnType {
   return {
+    name: 'max',
     type: 'low',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       if (args.inclusive)
         return {
           parsed: value,
@@ -37,9 +47,9 @@ export function max(args: NumberSchema['__max']): ValidationFallbackReturnType {
               code: 'max',
               // eslint-disable-next-line ts/no-unnecessary-condition
               path: path || [],
-              message: args.message,
-            },
-          ],
+              message: args.message
+            }
+          ]
         };
 
       return {
@@ -50,16 +60,17 @@ export function max(args: NumberSchema['__max']): ValidationFallbackReturnType {
             code: 'max',
             // eslint-disable-next-line ts/no-unnecessary-condition
             path: path || [],
-            message: args.message,
-          },
-        ],
+            message: args.message
+          }
+        ]
       };
-    },
+    }
   };
 }
 
-export function min(args: NumberSchema['__min']): ValidationFallbackReturnType {
+export function min(args: NonNullable<NumberSchema['__min']>): ValidationFallbackReturnType {
   return {
+    name: 'min',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path?: (string | number)[]) => {
@@ -71,9 +82,9 @@ export function min(args: NumberSchema['__min']): ValidationFallbackReturnType {
               isValid: value >= args.value,
               message: args.message,
               code: 'min',
-              path: path || [],
-            },
-          ],
+              path: path || []
+            }
+          ]
         };
 
       return {
@@ -83,44 +94,21 @@ export function min(args: NumberSchema['__min']): ValidationFallbackReturnType {
             isValid: value > args.value,
             message: args.message,
             code: 'min',
-            path: path || [],
-          },
-        ],
-      };
-    },
-  };
-}
-
-export function negative(args: NumberSchema['__allowNegative']): ValidationFallbackReturnType {
-  return {
-    type: 'low',
-    // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path?: (string | number)[]) => {
-      const isValid = args.allowZero ? value < 0 : value <= 0;
-
-      return {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: isValid,
-                message: args.message,
-                code: 'negative',
-                path: path || [],
-              },
-            ],
+            path: path || []
+          }
+        ]
       };
-    },
+    }
   };
 }
 
-export function positive(args: NumberSchema['__allowPositive']): ValidationFallbackReturnType {
+export function integer(args: NonNullable<NumberSchema['__integer']>): ValidationFallbackReturnType {
   return {
+    name: 'integer',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path?: (string | number)[]) => {
-      const isValid = args.allowZero ? value > 0 : value >= 0;
+      const isValid = Number.isInteger(value);
 
       return {
         parsed: value,
@@ -130,17 +118,18 @@ export function positive(args: NumberSchema['__allowPositive']): ValidationFallb
               {
                 isValid: isValid,
                 message: args.message,
-                code: 'positive',
-                path: path || [],
-              },
-            ],
+                code: 'integer',
+                path: path || []
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function maxDigits(args: NumberSchema['__maxDigits']): ValidationFallbackReturnType {
+export function maxDigits(args: NonNullable<NumberSchema['__maxDigits']>): ValidationFallbackReturnType {
   return {
+    name: 'maxDigits',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path?: (string | number)[]) => {
@@ -155,16 +144,17 @@ export function maxDigits(args: NumberSchema['__maxDigits']): ValidationFallback
                 isValid: isValid,
                 message: args.message,
                 code: 'maxDigits',
-                path: path || [],
-              },
-            ],
+                path: path || []
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function decimalPlaces(args: NumberSchema['__decimalPlaces']): ValidationFallbackReturnType {
+export function decimalPlaces(args: NonNullable<NumberSchema['__decimalPlaces']>): ValidationFallbackReturnType {
   return {
+    name: 'decimalPlaces',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path?: (string | number)[]) => {
@@ -179,10 +169,10 @@ export function decimalPlaces(args: NumberSchema['__decimalPlaces']): Validation
                 isValid: isValid,
                 message: args.message,
                 code: 'decimalPlaces',
-                path: path || [],
-              },
-            ],
+                path: path || []
+              }
+            ]
       };
-    },
+    }
   };
 }

package/src/validators/object.ts

@@ -3,6 +3,7 @@ import type { ValidationFallbackCallbackReturnType, ValidationFallbackReturnType
 
 export function objectValidation(keysToFallback: { [key: string]: Schema }): ValidationFallbackReturnType {
   return {
+    name: 'object',
     type: 'low',
     callback: async (value: any, path: (string | number)[], options: Parameters<Schema['__transformToAdapter']>[0]) => {
       const isNotAnObject = typeof value !== 'object' && Array.isArray(value) === false && value !== null;
@@ -17,9 +18,9 @@ export function objectValidation(keysToFallback: { [key: string]: Schema }): Val
               code: 'object',
               // eslint-disable-next-line ts/no-unnecessary-condition
               path: path || [],
-              message: 'The value must be an object. Received: ' + typeof value,
-            },
-          ],
+              message: 'The value must be an object. Received: ' + typeof value
+            }
+          ]
         };
 
       const errors: { [key: string]: ValidationFallbackCallbackReturnType['errors'] } = {};
@@ -48,8 +49,8 @@ export function objectValidation(keysToFallback: { [key: string]: Schema }): Val
 
       return {
         parsed: value,
-        errors: Object.values(errors).flat(),
+        errors: Object.values(errors).flat()
       };
-    },
+    }
   };
 }

package/src/validators/schema.ts

@@ -7,6 +7,7 @@ import type { ValidationFallbackReturnType } from '../schema/types';
 
 export function optional(args: Schema['__optional']): ValidationFallbackReturnType {
   return {
+    name: 'optional',
     type: 'high',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path: (string | number)[]) => {
@@ -15,7 +16,7 @@ export function optional(args: Schema['__optional']): ValidationFallbackReturnTy
           return {
             parsed: value,
             errors: [],
-            preventChildValidation: true,
+            preventChildValidation: true
           };
         return {
           parsed: value,
@@ -25,24 +26,25 @@ export function optional(args: Schema['__optional']): ValidationFallbackReturnTy
               message: args.message,
               code: 'required' as ErrorCodes,
               // eslint-disable-next-line ts/no-unnecessary-condition
-              path: path || [],
-            },
+              path: path || []
+            }
           ],
-          preventChildValidation: true,
+          preventChildValidation: true
         };
       }
 
       return {
         parsed: value,
         errors: [],
-        preventChildValidation: false,
+        preventChildValidation: false
       };
-    },
+    }
   };
 }
 
 export function nullable(args: Schema['__nullable']): ValidationFallbackReturnType {
   return {
+    name: 'nullable',
     type: 'high',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path: (string | number)[]) => {
@@ -51,7 +53,7 @@ export function nullable(args: Schema['__nullable']): ValidationFallbackReturnTy
           return {
             parsed: value,
             errors: [],
-            preventChildValidation: true,
+            preventChildValidation: true
           };
         return {
           parsed: value,
@@ -59,26 +61,27 @@ export function nullable(args: Schema['__nullable']): ValidationFallbackReturnTy
             {
               isValid: false,
               message: args.message,
-              code: 'cannot_be_null' as ErrorCodes,
+              code: 'null',
               // eslint-disable-next-line ts/no-unnecessary-condition
-              path: path || [],
-            },
+              path: path || []
+            }
           ],
-          preventChildValidation: true,
+          preventChildValidation: true
         };
       }
 
       return {
         parsed: value,
         errors: [],
-        preventChildValidation: false,
+        preventChildValidation: false
       };
-    },
+    }
   };
 }
 
-export function checkType(args: Schema['__type']): ValidationFallbackReturnType {
+export function checkType(args: NonNullable<Schema['__type']>): ValidationFallbackReturnType {
   return {
+    name: 'checkType',
     type: 'medium',
     // eslint-disable-next-line ts/require-await
     callback: async (value: any, path: (string | number)[]) => {
@@ -86,7 +89,7 @@ export function checkType(args: Schema['__type']): ValidationFallbackReturnType
         return {
           parsed: value,
           errors: [],
-          preventChildValidation: false,
+          preventChildValidation: false
         };
 
       return {
@@ -97,22 +100,27 @@ export function checkType(args: Schema['__type']): ValidationFallbackReturnType
             message: args.message,
             code: 'invalid_type' as ErrorCodes,
             // eslint-disable-next-line ts/no-unnecessary-condition
-            path: path || [],
-          },
+            path: path || []
+          }
         ],
-        preventChildValidation: true,
+        preventChildValidation: true
       };
-    },
+    }
   };
 }
 
 export function is(
-  args: BooleanSchema['__is'] | NumberSchema['__is'] | StringSchema['__is']
+  args: NonNullable<BooleanSchema['__is']> | NonNullable<NumberSchema['__is']> | NonNullable<StringSchema['__is']>
 ): ValidationFallbackReturnType {
   return {
+    name: 'is',
     type: 'medium',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = Array.isArray(args.value) ? args.value.includes(value as never) : value === args.value;
       return {
         parsed: value,
@@ -124,11 +132,11 @@ export function is(
                 code: 'is',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: 'Value is not a boolean',
-              },
+                message: 'Value is not a boolean'
+              }
             ],
-        preventChildValidation: true,
+        preventChildValidation: true
       };
-    },
+    }
   };
 }