@palmares/schemas 0.0.1

package/src/validators/number.ts

@@ -0,0 +1,188 @@
+import type NumberSchema from '../schema/number';
+import type Schema from '../schema/schema';
+import type { ValidationFallbackReturnType } from '../schema/types';
+
+export function numberValidation(): ValidationFallbackReturnType {
+  return {
+    type: 'medium',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: typeof value === 'number',
+            code: 'number',
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: 'The value must be a number. Received: ' + typeof value,
+          },
+        ],
+      };
+    },
+  };
+}
+
+export function max(args: NumberSchema['__max']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      if (args.inclusive)
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: value <= args.value,
+              code: 'max',
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || [],
+              message: args.message,
+            },
+          ],
+        };
+
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: value < args.value,
+            code: 'max',
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message,
+          },
+        ],
+      };
+    },
+  };
+}
+
+export function min(args: NumberSchema['__min']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path?: (string | number)[]) => {
+      if (args.inclusive)
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: value >= args.value,
+              message: args.message,
+              code: 'min',
+              path: path || [],
+            },
+          ],
+        };
+
+      return {
+        parsed: value,
+        errors: [
+          {
+            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 || [],
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function positive(args: NumberSchema['__allowPositive']): 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: 'positive',
+                path: path || [],
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function maxDigits(args: NumberSchema['__maxDigits']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path?: (string | number)[]) => {
+      const isValid = value.toString().replace('.', '').length <= args.value;
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: isValid,
+                message: args.message,
+                code: 'maxDigits',
+                path: path || [],
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function decimalPlaces(args: NumberSchema['__decimalPlaces']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path?: (string | number)[]) => {
+      const isValid = value.toString().split('.')[1]?.length <= args.value;
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: isValid,
+                message: args.message,
+                code: 'decimalPlaces',
+                path: path || [],
+              },
+            ],
+      };
+    },
+  };
+}

package/src/validators/object.ts

@@ -0,0 +1,55 @@
+import type Schema from '../schema/schema';
+import type { ValidationFallbackCallbackReturnType, ValidationFallbackReturnType } from '../schema/types';
+
+export function objectValidation(keysToFallback: { [key: string]: Schema }): ValidationFallbackReturnType {
+  return {
+    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;
+
+      if (isNotAnObject)
+        return {
+          parsed: value,
+          preventChildValidation: true,
+          errors: [
+            {
+              isValid: false,
+              code: 'object',
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || [],
+              message: 'The value must be an object. Received: ' + typeof value,
+            },
+          ],
+        };
+
+      const errors: { [key: string]: ValidationFallbackCallbackReturnType['errors'] } = {};
+      const toValidateEntries = Object.entries(keysToFallback);
+
+      await Promise.all(
+        toValidateEntries.map(async ([key, schema]) => {
+          const schemaWithProtected = schema as Schema & {
+            __parse: Schema['__parse'];
+            __toInternal: Schema['__toInternal'];
+          };
+          const { parsed, errors: parseErrors } = await schemaWithProtected.__parse(
+            value[key],
+            [...path, key],
+            options
+          );
+          if (Array.isArray(parseErrors) && parseErrors.length > 0) errors[key] = parseErrors;
+          else value[key] = parsed;
+
+          // We append the toInternalToBubbleUp to the parent toInternalToBubbleUp
+
+          if (schemaWithProtected.__toInternal && options.toInternalToBubbleUp)
+            options.toInternalToBubbleUp.push(async () => (value[key] = await (schema as any).__toInternal(parsed)));
+        })
+      );
+
+      return {
+        parsed: value,
+        errors: Object.values(errors).flat(),
+      };
+    },
+  };
+}

package/src/validators/schema.ts

@@ -0,0 +1,134 @@
+import type { ErrorCodes } from '../adapter/types';
+import type BooleanSchema from '../schema/boolean';
+import type NumberSchema from '../schema/number';
+import type Schema from '../schema/schema';
+import type StringSchema from '../schema/string';
+import type { ValidationFallbackReturnType } from '../schema/types';
+
+export function optional(args: Schema['__optional']): ValidationFallbackReturnType {
+  return {
+    type: 'high',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path: (string | number)[]) => {
+      if (value === undefined) {
+        if (args.allow === true)
+          return {
+            parsed: value,
+            errors: [],
+            preventChildValidation: true,
+          };
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: false,
+              message: args.message,
+              code: 'required' as ErrorCodes,
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || [],
+            },
+          ],
+          preventChildValidation: true,
+        };
+      }
+
+      return {
+        parsed: value,
+        errors: [],
+        preventChildValidation: false,
+      };
+    },
+  };
+}
+
+export function nullable(args: Schema['__nullable']): ValidationFallbackReturnType {
+  return {
+    type: 'high',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path: (string | number)[]) => {
+      if (value === null) {
+        if (args.allow === true)
+          return {
+            parsed: value,
+            errors: [],
+            preventChildValidation: true,
+          };
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: false,
+              message: args.message,
+              code: 'cannot_be_null' as ErrorCodes,
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || [],
+            },
+          ],
+          preventChildValidation: true,
+        };
+      }
+
+      return {
+        parsed: value,
+        errors: [],
+        preventChildValidation: false,
+      };
+    },
+  };
+}
+
+export function checkType(args: Schema['__type']): ValidationFallbackReturnType {
+  return {
+    type: 'medium',
+    // eslint-disable-next-line ts/require-await
+    callback: async (value: any, path: (string | number)[]) => {
+      if (args.check(value))
+        return {
+          parsed: value,
+          errors: [],
+          preventChildValidation: false,
+        };
+
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: false,
+            message: args.message,
+            code: 'invalid_type' as ErrorCodes,
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+          },
+        ],
+        preventChildValidation: true,
+      };
+    },
+  };
+}
+
+export function is(
+  args: BooleanSchema['__is'] | NumberSchema['__is'] | StringSchema['__is']
+): ValidationFallbackReturnType {
+  return {
+    type: 'medium',
+    // eslint-disable-next-line ts/require-await
+    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,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'is',
+                // eslint-disable-next-line ts/no-unnecessary-condition
+                path: path || [],
+                message: 'Value is not a boolean',
+              },
+            ],
+        preventChildValidation: true,
+      };
+    },
+  };
+}

package/src/validators/string.ts

@@ -0,0 +1,215 @@
+import type Schema from '../schema/schema';
+import type StringSchema from '../schema/string';
+import { type ValidationFallbackReturnType } from '../schema/types';
+
+export function stringValidation(): ValidationFallbackReturnType {
+  return {
+    type: 'medium',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      return {
+        parsed: value,
+        errors:
+          typeof value === 'string'
+            ? []
+            : [
+                {
+                  isValid: typeof value === 'string',
+                  code: 'string',
+                  path: path || [],
+                  message: 'The value must be a string. Received: ' + typeof value,
+                },
+              ],
+      };
+    },
+  };
+}
+
+export function maxLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'maxLength',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function minLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'minLength',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function endsWith(args: StringSchema['__endsWith']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = value.endsWith(args.value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'endsWith',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function startsWith(args: StringSchema['__startsWith']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = value.startsWith(args.value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'startsWith',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function includes(args: StringSchema['__includes']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = value.includes(args.value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'includes',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function regex(args: StringSchema['__regex']): ValidationFallbackReturnType {
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = args.value.test(value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'regex',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    },
+  };
+}
+
+export function uuid(args: StringSchema['__uuid']): ValidationFallbackReturnType {
+  // const uuidRegex =
+  //   /^([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 {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = uuidRegex.test(value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'uuid',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    }
+  }
+}
+
+export function email(args: StringSchema['__email']): ValidationFallbackReturnType {
+  const emailRegex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+  return {
+    type: 'low',
+    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+      const isValid = emailRegex.test(value);
+
+      return {
+        parsed: value,
+        errors: isValid
+          ? []
+          : [
+              {
+                isValid: false,
+                code: 'email',
+                path: path || [],
+                message: args.message,
+              },
+            ],
+      };
+    }
+  }
+}
+

package/src/validators/types.ts

@@ -0,0 +1 @@
+export type ValidatorTypes = 'low' | 'medium' | 'high';

package/src/validators/union.ts

@@ -0,0 +1,52 @@
+import type Schema from '../schema/schema';
+import type { ValidationFallbackReturnType } from '../schema/types';
+
+export function unionValidation(
+  schemas: readonly [Schema<any, any>, Schema<any, any>, ...Schema<any, any>[]]
+): ValidationFallbackReturnType {
+  return {
+    type: 'high',
+    callback: async (value, path, options) => {
+      const parsedValues: Awaited<ReturnType<Schema['__parse']>> = {
+        parsed: value,
+        errors: [],
+      };
+      const startingToInternalBubbleUpLength = options.toInternalToBubbleUp?.length || 0;
+
+      // eslint-disable-next-line ts/prefer-for-of
+      for (let i = 0; i < schemas.length; i++) {
+        const schemaWithProtected = schemas[i] as Schema & {
+          __parse: Schema['__parse'];
+          __toInternal: Schema['__toInternal'];
+        };
+        const parsedData = await schemaWithProtected.__parse(value, path, options);
+        parsedValues.parsed = parsedData.parsed;
+        if (Array.isArray(parsedData.errors))
+          if (Array.isArray(parsedValues.errors)) parsedValues.errors.push(...parsedData.errors);
+          else parsedValues.errors = parsedData.errors;
+
+        const hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors =
+          // eslint-disable-next-line ts/no-unnecessary-condition
+          parsedData.errors === undefined || (parsedData.errors || []).length === 0;
+        if (hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors) {
+          return {
+            parsed: parsedValues.parsed,
+            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.
+          const numberOfElementsToRemove =
+            (options.toInternalToBubbleUp?.length || 0) - startingToInternalBubbleUpLength;
+          options.toInternalToBubbleUp?.splice(startingToInternalBubbleUpLength, numberOfElementsToRemove);
+        }
+      }
+
+      return {
+        parsed: parsedValues.parsed,
+        // eslint-disable-next-line ts/no-unnecessary-condition
+        errors: parsedValues.errors ? parsedValues.errors : [],
+      };
+    },
+  };
+}