mvom/schemaType/StringType.js

Multivalue Object Mapper

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _dataTransformers = require("../dataTransformers");
var _ForeignKeyDbTransformer = _interopRequireDefault(require("../ForeignKeyDbTransformer"));
var _BaseScalarType = _interopRequireDefault(require("./BaseScalarType"));
/** String Schema Type */
class StringType extends _BaseScalarType.default {
  /** Data transformer */

  /** Array of allowed enumerations */

  /* Regular expression to validate the property value against */

  /* Transform schema foreign key definitions to the db format */

  constructor(definition, options = {}) {
    super(definition, options);
    const {
      enum: definitionEnum,
      match,
      foreignKey
    } = definition;
    this.enum = definitionEnum ?? null;
    this.match = match ?? null;
    this.foreignKeyDbTransformer = new _ForeignKeyDbTransformer.default(foreignKey);
    this.dataTransformer = new _dataTransformers.StringDataTransformer(definitionEnum);

    // add validators for this type
    this.validators.unshift(this.createMatchValidator());
    this.validators.unshift(this.createEnumValidator());
  }

  /** Create an array of foreign key definitions that will be validated before save */
  transformForeignKeyDefinitionsToDb(value) {
    return this.foreignKeyDbTransformer.transform(value);
  }

  /** String required validator */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types -- Use any instead of unknown to avoid type errors in enum validation
  validateRequired = value => !this.required || this.enum?.includes(value) || value != null && value !== '';

  /** Enum validator */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Use any instead of unknown to avoid type errors in enum validation
  validateEnum = value =>
  // skip validation on nullish values because a required validation error, if applicable, is more helpful
  value == null || this.enum == null || this.enum.includes(value);

  /** Create validation object for enum validation */
  createEnumValidator() {
    const message = 'Value not present in list of allowed values';
    return {
      validationFn: this.validateEnum,
      message
    };
  }

  /** Match validator */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  validateMatch = value =>
  // skip validation on nullish values because a required validation error, if applicable, is more helpful
  value == null || this.match == null || this.match.test(value);

  /** Create validation object for match validation */
  createMatchValidator() {
    const message = 'Value does not match pattern';
    return {
      validationFn: this.validateMatch,
      message
    };
  }
}
var _default = exports.default = StringType;