validation.js

"use strict";
var _ = require("lodash");
const isomorphicDomPurify = require("isomorphic-dompurify");
const helper = require('./lib/helper');
var debug = require("debug")("loopback:component-validator:validation");
var beforeSaveValidators = [];
var customValidators = [];

module.exports = (app, options) => {
  let customValidation = ["StringValidation", "NumberValidation", "domPurify"];

  if (options.disableAll === true) {
    return;
  }

  _.forEach(customValidation, prop => {
    if (typeof this[prop] === "function") {
      if (options[prop] != false) this[prop](app, options);
    } else {
      throw new Error(`Function defination for '${prop}' not given`);
    }
  });
  debug(options);

  attachBeforeSave(app);
};

this.StringValidation = app => {
  var stringValidator = require("./lib/stringValidation").setup(app);
  var deb = debug.extend("stringModels");
  deb(stringValidator);
  customValidators.push(stringValidator);
};
this.NumberValidation = app => {
  var numberValidator = require("./lib/numberValidation").setup(app);
  var deb = debug.extend("numberModels");
  deb(numberValidator);
  customValidators.push(numberValidator);
};

this.domPurify = (app, options) => {
  let stringModels = helper.populateModels(app, { key: "type", value: "string" });
  for (const model in stringModels) {
    app.models[model].observe("before save", async ctx => {
      const instance = ctx.instance || ctx.data;
      const purifyOpts = options.domPurify || {};
      for (const property in instance) {
        if(purifyOpts.skipProperties?.[model]?.includes?.(property)) continue;
        if (instance[property] && typeof instance[property] === 'string') {
          try {
            instance[property] = isomorphicDomPurify.sanitize(instance[property], {
              ...(purifyOpts.isomorphicDomPurifyOptions || {})
            });
          } catch (error) {
            console.error(error);
          }
        }
        else if (Array.isArray(instance[property])) {
          instance[property] = instance[property].map(item => {
            if (typeof item === 'string') {
              return isomorphicDomPurify.sanitize(item, {
                ...(options.domPurify?.isomorphicDomPurifyOptions || {})
              });
            }
            return item;
          }
          );
        }
      }
    })
  }
}

function attachBeforeSave(app) {
  _.keys(app.models).forEach(model => {
    app.models[model].observe("before save", async ctx => {
      for (let validator of customValidators) {
        let Model = app.models[model]
        if (validator[model] && typeof validator[model].validate === 'function')
          validator[model].validate(ctx, Model);
      }
    });
  });
}