@backland/schema/lib/fields/RecordField.js

TypeScript schema declaration and validation library with static type inference

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.RecordField = void 0;
var _utils = require("@backland/utils");
var _CircularDeps = require("../CircularDeps");
var _FieldType = require("./FieldType");
const validKeyTypes = ['int', 'string', 'float'];
class RecordField extends _FieldType.FieldType {
  __isRecordField = true;
  static is(input) {
    return !!(input && typeof input === 'object' && input.__isRecordField);
  }
  //

  constructor(def = {
    keyType: 'string',
    type: 'any'
  }) {
    super({
      def: def,
      name: 'record'
    });
    const {
      parseObjectField
    } = _CircularDeps.CircularDeps;
    let parser;
    try {
      parser = parseObjectField(`RecordField`, (def === null || def === void 0 ? void 0 : def.type) || 'any', true);
    } catch (e) {
      e.message = `RecordField: failed to create parser for record values: ${e.message}\n${(0, _utils.inspectObject)({
        receivedDef: def
      }, {
        tabSize: 2
      })}`;
      e.stack = e.message;
      throw e;
    }
    let keyParser;
    try {
      if (!validKeyTypes.includes(def.keyType)) {
        throw new Error(`keyType should be on of ${validKeyTypes}`);
      }
      keyParser = parseObjectField('RecordFieldKey', def.keyType, true);
    } catch (e) {
      e.message = `RecordField: failed to create parser for record keys: ${e.message}\n${(0, _utils.inspectObject)({
        receivedDef: def
      }, {
        tabSize: 2
      })}`;
      e.stack = e.message;
      throw e;
    }
    this.parse = this.applyParser({
      parse: input => {
        (0, _utils.expectedType)({
          value: input
        }, 'object');
        const result = {};
        for (let key in input) {
          keyParser.parse(key, (_, err) => {
            return `Unexpected record key \`${key}\`. ${err.message}`;
          });
        }
        for (let key in input) {
          try {
            result[key] = parser.parse(input[key]);
          } catch (e) {
            throw new Error(`field '${key}': ${e.message}`);
          }
        }
        return result;
      }
    });
  }
  static create = def => {
    def = {
      keyType: 'string',
      type: 'any',
      ...def
    };
    return new RecordField(def);
  };
}
exports.RecordField = RecordField;
//# sourceMappingURL=RecordField.js.map