@backland/schema/lib/module/mockObject.js

TypeScript schema declaration and validation library with static type inference

// Converts a schema to a placeholder object
import { randomFloat, randomInt, randomItem, randomName, setByPath, slugify, ulid as _ulid } from '@backland/utils';
import { CursorField } from './fields/CursorField';
import { LiteralField } from './fields/LiteralField';
import { createEmptyMetaField, isMetaFieldKey } from './fields/MetaFieldField';
import { __getCachedFieldInstance, parseObjectField } from './parseObjectDefinition';
export function objectMock(definition, options) {
  var placeHolder = {};
  var composers = [];
  Object.entries(definition).forEach(_ref => {
    var [key, fieldInput] = _ref;
    if (isMetaFieldKey(key)) return;
    var def = parseObjectField(key, fieldInput);
    if (def.type === 'alias') {
      var instance = __getCachedFieldInstance(def);
      composers.push({
        composer: instance.composer,
        key
      });
    }
    placeHolder[key] = fieldToMock(def, options);
  });
  composers.forEach(el => {
    setByPath(placeHolder, el.key, el.composer.compose(placeHolder));
  });
  return placeHolder;
}
export function fieldToMock(fieldInput, options) {
  var {
    randomText = randomName,
    maxArrayLength = 1,
    randomNumber
  } = options || {};
  var {
    list,
    def,
    type
  } = parseObjectField('temp', fieldInput);
  if (type === 'array') {
    var min = def.min === undefined ? 1 : def.min;
    var max = def.max === undefined ? Math.max(min, 1) : def.max;
    var length = Math.min(min, max);
    return [...Array(length)].map(() => {
      return fieldToMock(def.of, options);
    });
  }
  var values = {
    ID: () => _ulid(),
    alias: () => undefined,
    any: () => '_ANY_',
    array: () => undefined,
    // handled below,
    boolean: () => randomItem(true, false),
    cursor: () => objectMock(CursorField.object().definition, options),
    date: () => new Date(randomInt(Date.now())),
    email: () => {
      return "".concat(slugify(randomText().toLowerCase()), "@").concat(slugify(randomText().toLowerCase())).concat(randomItem('.com', '.net', '.com.br', '.co', '.sh'));
    },
    enum: () => Array.isArray(def) ? def[0] : undefined,
    float: () => (randomNumber || randomFloat)(),
    int: () => (randomNumber || randomInt)(),
    literal: () => LiteralField.utils.deserialize(def),
    meta: () => createEmptyMetaField(),
    null: () => null,
    object: () => def ? objectMock(def, options) : undefined,
    phone: () => '+5511912345678',
    record: () => ({
      [randomText()]: 123
    }),
    string: () => randomText(),
    ulid: () => _ulid(),
    undefined: function (_undefined) {
      function undefined() {
        return _undefined.apply(this, arguments);
      }
      undefined.toString = function () {
        return _undefined.toString();
      };
      return undefined;
    }(() => undefined),
    union: () => Array.isArray(def) ? fieldToMock(def[0]) : undefined,
    unknown: () => Date
  };
  if (list) {
    return [...Array(randomInt(Math.min(3, maxArrayLength), maxArrayLength))].map(() => {
      return values[type]();
    });
  }
  return values[type]();
}
//# sourceMappingURL=mockObject.js.map