#FAQ troubleshooting guide

const result = validate(schema, data);
console.log(result.valid); // false
console.log(result.errors); // Can't understand the error message

console.log(JSON.stringify(result.errors, null, 2));
// View the complete error object

const validator = new Validator({ verbose: true });
const result = validator.validate(schema, data);

import { SchemaHelper } from 'schema-dsl/pure';
console.log(SchemaHelper.summarizeSchema(schema));

// ❌ Error: path separated by.
{ 'user.name': 'string!' }

// ✅ Correct: use nested objects
{
  user: {
    name: 'string!'
  }
}

email: s('email!').custom(async (value) => {
  //The code here is not executed
})

// ❌ Error: using asynchronous validator in validate()
const result = validate(schema, data); // Synchronous mode

// ✅ Correct: Use validateAsync() to execute Promise-returning custom validator
await validateAsync(schema, data);

// ✅ Correct: use synchronous validator
email: s('email!').custom((value) => {
  // synchronization code
  if (checkSync(value)) return 'The mailbox has been occupied';
})

// ✅ Or: put the asynchronous check outside the schema-dsl
const result = validate(schema, data);
if (result.valid) {
  await checkEmailUniqueness(data.email);
}

// ✅ OK: return boolean
.custom((value) => {
  return value.includes('@'); // true passes, false uses default error message
})

// ✅ More recommended: return a readable error message on failure
.custom((value) => {
  if (!value.includes('@')) {
    return 'Must contain @ symbol'; // Return message on failure
  }
  // No need to return on success
})

const schema = s({
  user: {
    name: 'string!',
    email: 'email!'
  }
});

// Authentication failed: user field is not required

// ✅ Option 1: Mark the object itself as required
const schema = s({
  'user!': { // Note the!
    name: 'string!',
    email: 'email!'
  }
});

// ✅ Solution 2: Make sure there is a user object in the data
const data = {
  user: {
    name: 'John',
    email: 'john@example.com'
  }
};

tags: 'array!1-10<string>'
// Passed in an empty array but passed

// ❌ Incorrect syntax
'array!1-10<string>' //! Wrong position

// ✅ Correct syntax (two ways)
'array:1-10<string>!' // Method 1:! at the end
'array!1-10<string>' // Method 2: It will be automatically converted to array:1-10!

// It is recommended to use method 1, which is more clear.

// ❌ Cache is not used
app.post('/api/user', (req, res) => {
  const schema = s({ username: 'string!' }); // Create every time
  validate(schema, req.body);
});

// ✅ Use cache
const userSchema = s({ username: 'string!' }); // Create once
app.post('/api/user', (req, res) => {
  validate(userSchema, req.body); //reuse
});

const validator = new Validator();
const validateFn = validator.compile(schema); // Pre-compilation

//reuse
app.post('/api/user', (req, res) => {
  const result = validateFn(req.body);
});

// ❌ Complex regular expressions (may cause ReDoS)
.pattern(/^(a+)+$/)

// ✅ Simple and efficient regular rules
.pattern(/^[a-zA-Z0-9_]+$/)

// ❌ Loop validation
records.forEach(record => {
  validate(schema, record);
});

// ✅ Batch validation
validator.validateBatch(schema, records);

const validator = new Validator({ cache: true });

// Clean the cache regularly
setInterval(() => {
  validator.clearCache();
}, 3600000); // Clean up every hour

// Or clean it manually at the appropriate time
app.post('/admin/clear-cache', (req, res) => {
  validator.clearCache();
  res.json({ message: 'Cache cleared' });
});

import { Locale } from 'schema-dsl/pure';
console.log(Object.keys(Locale.locales));
// Should contain: ['zh-CN', 'en-US', 'ja-JP',...]

// ❌ The constructor will not set the language for this validation
const validator = new Validator();

// ✅ Specify the language one by one when validating
const result = validator.validate(schema, data, {
  locale: 'zh-CN'
});

const result = validator.validate(schema, data, {
  locale: 'zh-CN' // dynamically specified
});

// ❌ Error: Wrong keyword used
username: s('string:3-32!').messages({
  'length': 'Incorrect length' // Wrong keyword
})

// ✅ Correct: Use the correct keywords
username: s('string:3-32!').messages({
  'min': 'At least 3 characters',
  'max': 'Maximum 32 characters',
  'required': 'Username cannot be empty'
})

// ❌ Problem: SQL reserved words are used
const schema = s({
  order: 'string!', // 'order' is a SQL reserved word
  group: 'string' // 'group' is a SQL reserved word
});

// ✅ Solution: Use backticks to wrap or rename
const schema = s({
  order_id: 'string!',
  group_name: 'string'
});

// Some JSON Schema types have no direct correspondence in the database

// Check export results
const exporter = new MySQLExporter();
const ddl = exporter.export('users', schema);
console.log(ddl); // Check the generated SQL

const command = exporter.generateCreateCommand('users', schema);
console.log(command);
// Should contain validator field

db.createCollection('users', {
  validator: { $jsonSchema: mongoSchema },
  validationLevel: 'strict', // must be set
  validationAction: 'error' // An error message will be reported if validation fails.
});

s('string!').pattern(/test/);
// TypeError: "string!".pattern is not a function

// Re-enable direct string chaining:
import { installStringExtensions } from 'schema-dsl/pure';
installStringExtensions();

// Or use s() wrapper (non-intrusive)
const schema = s({
  username: s('string!').pattern(/test/)
});

// Remove or rename the external extension of the same name before importing schema-dsl.
delete String.prototype.label;

import { s } from 'schema-dsl/pure';

const schema = s({
  username: 'string:3-32!',
  email: 'email!'
});

console.log(JSON.stringify(schema, null, 2));
// View the actual generated JSON Schema structure

import { SchemaHelper } from 'schema-dsl/pure';

// View Schema structure summary
const summary = SchemaHelper.summarizeSchema(schema);
console.log(summary);
// Output field list, required quantity, complexity, etc.

// Enable verbose logging in development environment
process.env.SCHEMAIO_DEBUG = 'true';

const validator = new Validator({
  verbose: true,
  allErrors: true // Return all errors, not just the first one
});

//Write tests for your Schema
describe('User Schema', () => {
  it('should validate correct data', () => {
    const result = validate(userSchema, {
      username: 'john_doe',
      email: 'john@example.com'
    });
    expect(result.valid).to.be.true;
  });

  it('should reject invalid email', () => {
    const result = validate(userSchema, {
      username: 'john_doe',
      email: 'invalid'
    });
    expect(result.valid).to.be.false;
    expect(result.errors[0].path).to.equal('email');
  });
});