Core

AField<T>

Core abstract class for all possible fields. Configs present in its initialization context can be applied to any field and will work the same.

const field: AField<number> = new NumberField({
   /* Marks field as getter which should not be expected in data during conversion */
   isCalculated: false,
   /* Marks that field can have null or undefined as value
      and this should NOT be considered as corruption*/
   isNullable: false,
   /* Validates provided value based on field validation settings */
   validators: [
      value => {
         if (value % 2 === 0) return; // #Return#
         return { code: 666, message: `Odd number`, value };
      }
   ]
});

Calculated

Marks that value is calculated by getter and will NOT be present in data.

class User {
   public id: number;
   public name: string;
   public get formatted() { return `${this.id} | ${this.name}`; }
}

const formattedField = new StringField({ isCalculated: true });
const USER_META = new ObjectMeta({
   builder: User,
   fields: {
      id: new NumberField(),
      name: new StringField(),
      formatted: formattedField,
   }
});

const users = [
   {
      id: 1,
      name: `Masha`,
   }
];

const result = JTC.convert({
   id: `Calculated`,
   meta: new ObjectArrayMeta({ meta: USER_META }),
   values: users
});

/* true */
console.log(formattedField.isCalculated);
/* false */
console.log(result.isCorrupted);
/* 1 | Masha */
console.log(result.converted.all[0].formatted);

Nullable

Marks that value can be null or undefined and this should NOT be considered as corruption.

If provided data doesn't contain value under nullable key value setted during instance creation will be used.

enum ERole {
   user = `user`,
   admin = `admin`,
}

class User {
   public id: number;
   public name?: string;
   public age?: number = null;
   public role: ERole = ERole.user;
}

const roleField = new StringField({ isNullable: true });
const USER_META = new ObjectMeta({
   builder: User,
   fields: {
      id: new NumberField(),
      name: new StringField({ isNullable: true }),
      age: new NumberField({ isNullable: true }),
      role: roleField,
   }
});

const users = [
   {
      id: 1,
      name: `Masha`,
   },
   {
      id: 2,
      age: 21
   },
   {
      id: 3,
      name: null,
      role: ERole.admin,
   },
];

const result = JTC.convert({
   id: `Nullable`,
   meta: new ObjectArrayMeta({ meta: USER_META }),
   values: users
});

/* true */
console.log(roleField.isNullable);
/* false */
console.log(result.isCorrupted);
/* { id: 1, name: 'Masha', age: null, role: 'user' } */
console.log(result.converted.all[0]);
/* { id: 2, age: 21, role: 'user' } */
console.log(result.converted.all[1]);
/* { id: 3, age: null, role: 'admin' } */
console.log(result.converted.all[2]);

Validators

Array of functions which check incoming value and returns nothing if it is valid or object with info describing invalidity.

class User {
   public id: number;
   public name: string;
}

const digitsCountValidator: (count: number) => TValidator<number> =
   (count: number) => (value: number) => {
      if (`${value}`.length != count) {
         return {
            code: 666,
            message: `Should consist of ${count} digits`,
            value,
         }
      }
   };

const wordsCountValidator: (count: number) => TValidator<string> =
   (count: number) => (value: string) => {
      if (value.split(` `).length != count) {
         return {
            code: 333,
            message: `Should consist of ${count} words`,
            value,
         }
      }
   };

const idField = new NumberField({
   validators: [
      digitsCountValidator(6)
   ]
});
const nameField = new StringField({
   validators: [
      wordsCountValidator(3),
   ]
});
const USER_META = new ObjectMeta({
   builder: User,
   fields: {
      id: idField,
      name: nameField,
   }
});

const users = [
   {
      id: 1,
      name: `Masha`,
   },
   {
      id: 222222,
      name: `Petya`,
   },
   {
      id: 3333,
      name: `Petrov Eugene Vasilievich`,
   },
   {
      id: 444444,
      name: `Holubiev Andrii Mykolayovych`,
   }
];

const result = JTC.convert({
   id: `Calculated`,
   meta: new ObjectArrayMeta({ meta: USER_META }),
   values: users
});

const log = JTC.log.asString(result.tree);

/* true */
console.log(result.isCorrupted);
/* 0 -> id -> 1 | Should consist of 6 digits
   0 -> name -> Masha | Should consist of 3 words
   1 -> name -> Petya | Should consist of 3 words
   2 -> id -> 3333 | Should consist of 6 digits
*/
console.log(log);

const idErrors = idField.validate({ value: 1 }).errors;
const nameErrors = nameField.validate({ value: `Masha` }).errors;

/*  [ { code: 666, message: 'Should consist of 6 digits', value: 1 } ] */
console.log(idErrors);
/*  [ { code: 333, message: 'Should consist of 3 words', value: 'Masha' } ] */
console.log(nameErrors);