check-rule-mate 0.5.3 → 0.5.4

package/README.md

@@ -58,6 +58,7 @@ This separation makes the system flexible, scalable, and easy to maintain.
 - i18n-ready error messages
 - Framework-agnostic (frontend or backend)
 - Auto documentation (automatic generated by a CLI command)
+- Template checker (automatic checked by a CLI command)
 
 ## Table of Contents
 
@@ -69,6 +70,7 @@ This separation makes the system flexible, scalable, and easy to maintain.
   - [Basic Usage](#Basic-Usage)
   - [Lifecycle Hooks](#Lifecycle-Hooks)
   - [Auto documentation](#Auto-Documentation)
+  - [Auto Checker for Templates](#Auto-Checker-for-Templates)
 - [Defining Validation](#Defining-Validation)
   - [1. Schema](#Defining-a-Schema-What-to-validate)
   - [2. Rules](#Defining-Rules-How-to-validate)
@@ -291,11 +293,41 @@ await validator.validate();
 To use that it is simple, you only need to run this command:
 
 ```bash
-npx check-rule-mate-auto-docs --rules rules-path --schemas schemas-path --errors errors-path --out file.html
+npx check-rule-mate-auto-docs --rules {rules path} --schemas {schemas path} --errors {errors path} --out file.html
 ```
 
 This will generate a HTML file containing the rules, schemas and errors.
 
+### Auto Checker for Templates
+You can **auto check** if your template it is working properly with all necessary properties or have something missing.
+
+It is works with: `Schemas`, `Rules` and `Errors`
+
+```bash
+npx check-rule-mate-verify-templates --rules {rules path} --schemas {schemas path} --errors {errors path}
+```
+
+If everything it is **working properly** this should be your message:
+```bash
+✔ Schemas loaded: 4
+✔ Rules loaded: 6
+✔ Errors loaded: 6
+
+✔ No issues found
+```
+
+Else if some error was found could be something like that:
+```bash
+✔ Schemas loaded: 4
+✔ Rules loaded: 6
+✔ Errors loaded: 6
+
+❌ Validation failed
+
+❌ Schema "contactUs.json" → field "phone" references rule "cellphone" which does not exist
+```
+
+
 ## Defining Validation
 
 ### Defining a Schema (What to validate)

package/bin/verify-templates.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+// import fs from 'fs';
+// import path from 'path';
+// import process from 'process';
+
+const fs = require('fs');
+const path = require('path');
+const process = require('process');
+
+/**
+ * ---------------------------
+ * Utils
+ * ---------------------------
+ */
+
+function readJSONFilesFromDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    throw new Error(`Directory not found: ${dirPath}`);
+  }
+
+  const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+
+  const data = {};
+  for (const file of files) {
+    const fullPath = path.join(dirPath, file);
+    const content = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+    data[file] = content;
+  }
+
+  return data;
+}
+
+function parseRuleName(ruleName) {
+  const [base, modifier] = ruleName.split('--');
+  return { base, modifier };
+}
+
+function error(msg) {
+  return { type: 'error', message: msg };
+}
+
+function warning(msg) {
+  return { type: 'warning', message: msg };
+}
+
+/**
+ * ---------------------------
+ * Core Validators
+ * ---------------------------
+ */
+
+function validateSchemas({ schemas, rules }) {
+  const issues = [];
+
+  for (const [schemaFile, schema] of Object.entries(schemas)) {
+    for (const [field, config] of Object.entries(schema)) {
+      if (!config.rule) continue;
+
+      const { base, modifier } = parseRuleName(config.rule);
+
+      if (!rules[base]) {
+        issues.push(
+          error(
+            `Schema "${schemaFile}" → field "${field}" references rule "${base}" which does not exist`
+          )
+        );
+        continue;
+      }
+
+      if (modifier) {
+        if (!rules[base].modifier || !rules[base].modifier[modifier]) {
+          issues.push(
+            error(
+              `Schema "${schemaFile}" → field "${field}" references modifier "${modifier}" on rule "${base}" which does not exist`
+            )
+          );
+        }
+      }
+    }
+  }
+
+  return issues;
+}
+
+function validateRuleErrors({ rules, errors }) {
+  const issues = [];
+
+  for (const [ruleName, rule] of Object.entries(rules)) {
+    const checkErrorMap = (errorMap, context) => {
+      if (!errorMap) return;
+
+      for (const errorKey of Object.values(errorMap)) {
+        const [namespace, key] = errorKey.split('.');
+        if (!errors[namespace] || !errors[namespace][key]) {
+          issues.push(
+            error(
+              `Rule "${ruleName}"${context} references error key "${errorKey}" which does not exist`
+            )
+          );
+        }
+      }
+    };
+
+    checkErrorMap(rule.error, '');
+
+    if (rule.modifier) {
+      for (const [modifierName, modifier] of Object.entries(rule.modifier)) {
+        checkErrorMap(modifier.error, ` (modifier "${modifierName}")`);
+      }
+    }
+  }
+
+  return issues;
+}
+
+function findUnusedErrors({ rules, errors }) {
+  const issues = [];
+  const usedErrors = new Set();
+
+  const collectErrors = errorMap => {
+    if (!errorMap) return;
+    Object.values(errorMap).forEach(e => usedErrors.add(e));
+  };
+
+  for (const rule of Object.values(rules)) {
+    collectErrors(rule.error);
+    if (rule.modifier) {
+      Object.values(rule.modifier).forEach(m => collectErrors(m.error));
+    }
+  }
+
+  for (const [namespace, keys] of Object.entries(errors)) {
+    for (const key of Object.keys(keys)) {
+      const fullKey = `${namespace}.${key}`;
+      if (!usedErrors.has(fullKey)) {
+        issues.push(
+          warning(`Unused error message detected: "${fullKey}"`)
+        );
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * ---------------------------
+ * CLI Argument Parsing
+ * ---------------------------
+ */
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].replace('--', '');
+      options[key] = args[i + 1];
+      i++;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * ---------------------------
+ * Runner
+ * ---------------------------
+ */
+
+async function runVerify() {
+  try {
+    const args = parseArgs();
+
+    if (!args.schemas || !args.rules || !args.errors) {
+      console.error(
+        'Usage: check-rule-mate-verify-templates --schemas <path> --rules <path> --errors <path>'
+      );
+      process.exit(1);
+    }
+
+    const schemas = readJSONFilesFromDir(args.schemas);
+    const rulesRaw = readJSONFilesFromDir(args.rules);
+    const errorsRaw = readJSONFilesFromDir(args.errors);
+
+    // Merge all rule files into one object
+    const rules = Object.assign({}, ...Object.values(rulesRaw));
+    const errors = Object.assign({}, ...Object.values(errorsRaw));
+
+    let issues = [];
+
+    issues.push(...validateSchemas({ schemas, rules }));
+    issues.push(...validateRuleErrors({ rules, errors }));
+    issues.push(...findUnusedErrors({ rules, errors }));
+
+    const hasErrors = issues.some(i => i.type === 'error');
+
+    console.log('✔ Schemas loaded:', Object.keys(schemas).length);
+    console.log('✔ Rules loaded:', Object.keys(rules).length);
+    console.log('✔ Errors loaded:', Object.keys(errors).length);
+    console.log('');
+
+    if (issues.length === 0) {
+      console.log('✔ No issues found');
+      process.exit(0);
+    }
+
+    console.log(hasErrors ? '❌ Validation failed' : '⚠️ Validation warnings');
+    console.log('');
+
+    for (const issue of issues) {
+      const prefix = issue.type === 'error' ? '❌' : '⚠️';
+      console.log(`${prefix} ${issue.message}`);
+    }
+
+    process.exit(hasErrors ? 1 : 0);
+  } catch (err) {
+    console.error('Fatal error:', err.message);
+    process.exit(1);
+  }
+}
+
+runVerify();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "check-rule-mate",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "",
   "main": "./dist/main.cjs.js",
   "type": "commonjs",
@@ -18,7 +18,8 @@
     "check rule mate"
   ],
   "bin": {
-    "check-rule-mate-auto-docs": "./bin/generate-docs.js"
+    "check-rule-mate-auto-docs": "./bin/generate-docs.js",
+    "check-rule-mate-verify-templates": "./bin/verify-templates.js"
   },
   "scripts": {
     "start": "node ./examples/vanilla/src/index.js",