nox-validation 1.0.1

package/README.md

@@ -0,0 +1,198 @@
+# Nox Validation
+
+`nox-validation` is a powerful and flexible validation library for both client-side and server-side use. It supports nested fields, alias validation, and customizable rules, making it perfect for complex form data validation.
+
+## Installation
+
+```bash
+npm install nox-validation
+```
+
+## Library Exports
+
+### **Validation Functions:**
+- `validate` - The core function for validating data.
+
+### **Constants:**
+- `CONSTANTS` - A collection of predefined constants (likely including data types, error messages, validation rules, etc.).
+
+### **Helper Functions (`HELPERS`):**
+- `validateSingleField` - Validates a single field against defined rules.
+- `validateType` - Performs type checks for data validation.
+- `fieldsMapping` - Groups fields by `schemaId` for structured access.
+- `convertTree` - Converts a flat structure into a nested tree format.
+- `getValueByDynamicKey` - Retrieves a value dynamically from an object using a key path.
+- `setValueByDynamicKey` - Sets a value dynamically in an object using a key path.
+
+## Usage
+
+
+```javascript
+const { validate, helpers } = require("nox-validation");
+
+const all_fields = []; // fields of all collection
+
+const relations = []; // all relations data
+
+const schema = [
+  {
+    _id: "67d2996955b853593b84a0c8",
+    schema_id: "67d2993655b853593b84a086",
+    field: "email",
+    field_type: "Single",
+    type: "String",
+    path: "email",
+    meta: {
+      field: "email",
+      interface: "input",
+      hidden: false,
+      sort: null,
+      required: true,
+      nullable: false,
+      validations: {
+        rules: [
+          {
+            rule: "matchesRegExp",
+            matchesRegExp: {
+              value: "/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/",
+            },
+          },
+        ],
+      },
+      readonly: false,
+    },
+    schema_definition: {
+      name: "email",
+      type: "String",
+      default: null,
+      unique: true,
+    },
+  },
+  {
+    _id: "67d2995955b853593b84a0bc",
+    schema_id: "67d2993655b853593b84a086",
+    field: "user_name",
+    field_type: "Single",
+    type: "String",
+    path: "user_name",
+    meta: {
+      field: "user_name",
+      interface: "input",
+      hidden: false,
+      sort: null,
+      required: true,
+      nullable: false,
+      readonly: false,
+    },
+    schema_definition: {
+      name: "user_name",
+      type: "String",
+      default: null,
+    },
+  },
+];
+
+```
+
+#### When `isSeparatedFields` is `true`
+```javascript
+const result = validate({
+  formData: {
+    user_name: "John Doe",
+    email: "john.doe@example.com",
+  },
+  isSeparatedFields: true,
+  fields: schema,
+  relationalFields: helpers.fieldsMapping(all_fields),
+  relations: relations,
+  formId: "67d2993655b853593b84a086",
+  abortEarly: false,
+  byPassKeys: [],
+  apiVersion: "v1",
+});
+```
+
+#### When `isSeparatedFields` is `false`
+```javascript
+const result = validate({
+  formData: {
+    user_name: "John Doe",
+    email: "john.doe@example.com",
+  },
+  isSeparatedFields: false,
+  fields: all_fields,
+  relationalFields: {},
+  relations: relations,
+  formId: "67d2993655b853593b84a086",
+  abortEarly: false,
+  byPassKeys: [],
+  apiVersion: "v1",
+});
+```
+
+#### Output Example:
+```javascript
+{
+  status: true, // Validation passed
+  error: {},    // Empty if no errors
+  data: {}      // Validated data
+}
+```
+
+## Parameters
+
+### Schema Parameter Descriptions:
+
+#### `formData` (Object)
+
+- Represents the primary data structure for form submission.
+- Contains key-value pairs corresponding to form fields.
+
+#### `formId` (ObjectId)
+
+- A unique identifier for the form schema.
+- Required when `isSeparatedFields` is `true`, indicating that only form-specific fields are provided.
+
+#### `isSeparatedFields` (Boolean)
+
+- Determines how fields are structured in the request.
+- **If `true`** → Only form schema fields are included in `fields`.
+- **If `false`** → All fields for a specific tenant are included. Additionally, `relationalFields` will contain `{ schema_id: [related fields] }`.
+
+#### `relations` (Array of Objects)
+
+- Defines the relationships between different entities.
+- Contains objects specifying relation types and linked entities.
+
+#### `fields` (Array of Objects)
+
+- Holds the form schema fields when `isSeparatedFields` is `true`.
+- If `false`, it contains all fields for the specific tenant.
+
+#### `relationalFields` (Object)
+
+- Maps schema IDs to their related fields.
+- Used when `isSeparatedFields` is `false` to maintain relationships between schemas and related fields.
+
+#### `abortEarly` (Boolean)
+
+- Determines validation behavior.
+- **If `true`** → Validation stops on the first error encountered.
+- **If `false`** → All validation errors are collected and returned.
+
+#### `byPassKeys` (Array of Strings)
+
+- Contains field names that should be skipped during validation.
+- Allows exclusion of specific fields from validation checks.
+
+#### `apiVersion` (String)
+
+- Specifies the API version (`"v1"` or `"v2"`).
+- Helps in maintaining compatibility and version control.
+
+## Result
+
+The `validate` function returns an object with two keys:
+
+- `status` (_boolean_): `true` if validation passed, `false` if there were errors.
+- `error` (_object_): Contains validation errors, with field paths as keys and error messages as values.

package/index.js

@@ -0,0 +1,23 @@
+const { validate, validateField, typeChecks } = require("./lib/validate");
+const constants = require("./lib/constant");
+const {
+  getFieldsGroupBySchemaId,
+  buildNestedStructure,
+  getValue,
+  setValue,
+  getDefaultValues
+} = require("./lib/helpers");
+
+module.exports = {
+  validate,
+  CONSTANTS: constants,
+  helpers: {
+    validateSingleField: validateField,
+    validateType: typeChecks,
+    fieldsMapping:getFieldsGroupBySchemaId,
+    convertTree:buildNestedStructure,
+    getValueByDynamicKey:getValue,
+    setValueByDynamicKey:setValue,
+    getTreeDefaultValues:getDefaultValues
+  },
+};

package/lib/constant.js

@@ -0,0 +1,165 @@
+const dataTypes = Object.freeze({
+  STRING: "String",
+  ARRAY: "Array",
+  OBJECT: "Object",
+  INT: "Int",
+  BINARY: "Binary",
+  BOOLEAN: "Boolean",
+  CODE: "Code",
+  DATE: "Date",
+  DECIMAL128: "Decimal128",
+  DOUBLE: "Double",
+  INT32: "Int32",
+  INT64: "Int64",
+  MAX_KEY: "MaxKey",
+  MIN_KEY: "MinKey",
+  NULL: "Null",
+  OBJECT_ID: "ObjectId",
+  BSON_REGEXP: "BSONRegExp",
+  BSON_SYMBOL: "BSONSymbol",
+  TIMESTAMP: "Timestamp",
+  UNDEFINED: "Undefined",
+  BIGINT: "BigInt",
+  SYMBOL: "Symbol",
+});
+
+const operatorTypes = Object.freeze({
+  AND: "$and",
+  OR: "$or",
+  EQUAL: "$eq",
+  NOT_EQUAL: "$ne",
+  LESS_THAN: "$lt",
+  LESS_THAN_EQUAL: "$lte",
+  GREATER_THAN: "$gt",
+  GREATER_THAN_EQUAL: "$gte",
+  IN: "$in",
+  NOT_IN: "$nin",
+  EXISTS: "$exists",
+  TYPE: "$type",
+  MOD: "$mod",
+  ALL: "$all",
+  SIZE: "$size",
+});
+
+const rulesTypes = Object.freeze({
+  EMPTY: "empty",
+  NOT_EMPTY: "not_empty",
+  ONE_OF: "one_of",
+  NOT_ONE_OF: "not_one_of",
+  NOT_ALLOWED: "not_allow",
+  REGEX: "regex",
+  MIN: "min_length",
+  MAX: "max_length",
+  OPERATOR: "Operator",
+  FIELD_COMPARE: "field_compare",
+  RULES_COMPARE: "rules_compare",
+});
+
+const rulesMessages = Object.freeze({
+  EMPTY: `{field} should be empty.`,
+  NOT_EMPTY: `{field} should not be empty.`,
+  ONE_OF: `{field} should be one of the following: {value}.`,
+  NOT_ONE_OF: `{field} should not be one of the following: {value}.`,
+  REQUIRED: `{field} is required.`,
+  OPTIONAL: `{field} is optional.`,
+  NOT_NULLABLE: `{field} can not be null.`,
+  INVALID_TYPE: "{field} contains invalid input type. Only {type} is allowed.",
+  NOT_ALLOWED_FIELD: `{field} is not allowed.`,
+  COMPARE: `{field} does not match the expected value.`,
+  RULES_COMPARE: `{field} does not meet the comparison rules.`,
+  ALLOW: `{field} contains allowed characters only.`,
+  NOT_ALLOWED: `{field} contains disallowed characters.`,
+  REGEX_MATCH: `{field} format is invalid.`,
+  REGEX_START_WITH: `{field} should start with {value}.`,
+  REGEX_ENDS_WITH: `{field} should end with {value}.`,
+  REGEX_CONTAINS: `{field} should contain {value}.`,
+  REGEX_EXACT: `{field} should be exactly {value}.`,
+  REGEX_NOT_START_WITH: `{field} should not be start with {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} should not be ends with {value}.`,
+  REGEX_NOT_CONTAINS: `{field} should not contains {value}.`,
+  MIN_STRING: `{field} must be at least {min} characters long.`,
+  MAX_STRING: `{field} must be at most {max} characters long.`,
+  MIN_NUMBER: `{field} must be at least {min}.`,
+  MAX_NUMBER: `{field} must be at most {max}.`,
+  AND: "{field} must be any of {value}",
+  OR: "{field} must be any of {value}",
+  EQUAL: "{field} must be equal to {value}",
+  NOT_EQUAL: "{field} must not be equal to {value}",
+  LESS_THAN: "{field} must be less than {value}",
+  LESS_THAN_EQUAL: "{field} must be less than or equal to {value}",
+  GREATER_THAN: "{field} must be greater than {value}",
+  GREATER_THAN_EQUAL: "{field} must be greater than or equal to {value}",
+  IN: "{field} must be one of the following: {value}",
+  NOT_IN: "{field} must not contain any of these values: {value}",
+  EXISTS: "{field} must exist",
+  TYPE: "{field} must be of type {value}",
+  MOD: "{field} must have a remainder of {value[1]} when divided by {value[0]}",
+  ALL: "{field} must contain all of the following values: {value}",
+  SIZE: "{field} must have a size of {value}",
+});
+
+const regexTypes = Object.freeze({
+  MATCH: "match",
+  START_WITH: "start_with",
+  ENDS_WITH: "ends_with",
+  CONTAINS: "contains",
+  EXACT: "exact",
+  NOT_START_WITH: "not_start_with",
+  NOT_ENDS_WITH: "not_ends_with",
+  NOT_CONTAINS: "not_contains",
+});
+
+const fieldTypes = Object.freeze({
+  SINGLE: "Single",
+  OBJECT: "Object",
+  ARRAY: "Array",
+});
+
+const types = Object.freeze({
+  STRING: "String",
+  OBJECT: "Object",
+  ARRAY: "Array",
+  DATE: "Date",
+  NUMBER: "Number",
+  ALIAS: "Alias",
+  OBJECT_ID: "ObjectId",
+  BUFFER: "Buffer",
+  BOOLEAN: "Boolean",
+  MIXED: "Mixed",
+  DATE_TIME: "datetime",
+  TIME: "time",
+});
+
+const interfaces = Object.freeze({
+  TIMESTAMP: "timestamp",
+  INPUT: "input",
+  MANY_TO_MANY: "list-m2m",
+  ONE_TO_MANY: "list-o2m",
+  MANY_TO_ONE: "list-m2o",
+  MANY_TO_ANY: "list-m2a",
+  FILE: "file",
+  FILE_IMAGE: "file-image",
+  FILES: "files",
+  TRANSLATIONS: "translations",
+  RELATIONAL: "relational",
+});
+
+const API_VERSION = Object.freeze({
+  V1: "v1",
+  V2: "v2",
+});
+
+const API_VERSIONS = Object.freeze(Object.values(API_VERSION));
+
+module.exports = {
+  dataTypes,
+  operatorTypes,
+  rulesTypes,
+  rulesMessages,
+  regexTypes,
+  types,
+  fieldTypes,
+  interfaces,
+  API_VERSIONS,
+  API_VERSION,
+};