@travetto/schema-faker 7.0.0-rc.1 → 7.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema-faker",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Data generation for schema-registered objects.",
   "keywords": [
     "faker",
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@faker-js/faker": "^10.1.0",
-    "@travetto/schema": "^7.0.0-rc.1"
+    "@travetto/schema": "^7.0.0-rc.3"
   },
   "travetto": {
     "displayName": "Schema Faker"

package/src/faker.ts

@@ -1,7 +1,7 @@
 import { faker } from '@faker-js/faker';
 
 import { Class, TimeUtil } from '@travetto/runtime';
-import { BindUtil, SchemaFieldConfig, CommonRegExp, SchemaRegistryIndex } from '@travetto/schema';
+import { BindUtil, SchemaFieldConfig, CommonRegex, SchemaRegistryIndex } from '@travetto/schema';
 
 
 /**
@@ -10,10 +10,10 @@ import { BindUtil, SchemaFieldConfig, CommonRegExp, SchemaRegistryIndex } from '
 export class SchemaFaker {
 
   static #stringToReType = new Map<RegExp, () => string>([
-    [CommonRegExp.email, faker.internet.email],
-    [CommonRegExp.url, faker.internet.url],
-    [CommonRegExp.telephone, faker.phone.number],
-    [CommonRegExp.postalCode, faker.location.zipCode]
+    [CommonRegex.email, faker.internet.email],
+    [CommonRegex.url, faker.internet.url],
+    [CommonRegex.telephone, faker.phone.number],
+    [CommonRegex.postalCode, faker.location.zipCode]
   ]);
 
   /**
@@ -61,29 +61,29 @@ export class SchemaFaker {
 
   /**
    * Get an array of values
-   * @param cfg Field configuration
+   * @param config Field configuration
    */
-  static #array(cfg: SchemaFieldConfig): unknown[] {
-    const min = cfg.minlength ? cfg.minlength.n : 0;
-    const max = cfg.maxlength ? cfg.maxlength.n : 10;
+  static #array(config: SchemaFieldConfig): unknown[] {
+    const min = config.minlength ? config.minlength.limit : 0;
+    const max = config.maxlength ? config.maxlength.limit : 10;
     const size = faker.number.int({ min, max });
     const out: unknown[] = [];
     for (let i = 0; i < size; i++) {
-      out.push(this.#value(cfg, true));
+      out.push(this.#value(config, true));
     }
     return out;
   }
 
   /**
    * Get a new number value
-   * @param cfg Number config
+   * @param config Number config
    */
-  static #number(cfg: SchemaFieldConfig): number {
-    let min = cfg.min && typeof cfg.min.n === 'number' ? cfg.min.n : undefined;
-    let max = cfg.max && typeof cfg.max.n === 'number' ? cfg.max.n : undefined;
-    let precision = cfg.precision;
+  static #number(config: SchemaFieldConfig): number {
+    let min = config.min && typeof config.min.limit === 'number' ? config.min.limit : undefined;
+    let max = config.max && typeof config.max.limit === 'number' ? config.max.limit : undefined;
+    let precision = config.precision;
 
-    if (/(price|amt|amount)$/i.test(cfg.name.toString())) {
+    if (/(price|amt|amount)$/i.test(config.name)) {
       precision = [13, 2];
     }
 
@@ -102,25 +102,25 @@ export class SchemaFaker {
 
     const range = (max - min) * offset;
 
-    const val = Math.trunc(Math.random() * range);
+    const result = Math.trunc(Math.random() * range);
 
-    return (val / offset) + min;
+    return (result / offset) + min;
   }
 
   /**
    * Get a date value
-   * @param cfg Field config
+   * @param config Field config
    */
-  static #date(cfg: SchemaFieldConfig): Date {
-    const name = cfg.name.toString().toLowerCase();
-    const min = cfg.min && typeof cfg.min.n !== 'number' ? cfg.min.n : undefined;
-    const max = cfg.max && typeof cfg.max.n !== 'number' ? cfg.max.n : undefined;
+  static #date(config: SchemaFieldConfig): Date {
+    const name = config.name.toLowerCase();
+    const min = config.min && typeof config.min.limit !== 'number' ? config.min.limit : undefined;
+    const max = config.max && typeof config.max.limit !== 'number' ? config.max.limit : undefined;
 
     if (min !== undefined || max !== undefined) {
       return faker.date.between({ from: min || TimeUtil.fromNow(-50, 'd'), to: max || new Date() });
     } else {
-      for (const [re, fn] of this.#namesToType.date) {
-        if (re.test(name)) {
+      for (const [regex, fn] of this.#namesToType.date) {
+        if (regex.test(name)) {
           return fn();
         }
       }
@@ -130,22 +130,22 @@ export class SchemaFaker {
 
   /**
    * Get a string value
-   * @param cfg Field config
+   * @param config Field config
    */
-  static #string(cfg: SchemaFieldConfig): string {
-    const name = cfg.name.toString().toLowerCase();
+  static #string(config: SchemaFieldConfig): string {
+    const name = config.name.toLowerCase();
 
-    if (cfg.match) {
-      const mre = cfg.match && cfg.match.re;
-      for (const [re, fn] of this.#stringToReType) {
-        if (mre === re) {
+    if (config.match) {
+      const mre = config.match && config.match.regex;
+      for (const [regex, fn] of this.#stringToReType) {
+        if (mre === regex) {
           return fn();
         }
       }
     }
 
-    for (const [re, fn] of this.#namesToType.string) {
-      if (re.test(name)) {
+    for (const [regex, fn] of this.#namesToType.string) {
+      if (regex.test(name)) {
         return fn();
       }
     }
@@ -155,23 +155,23 @@ export class SchemaFaker {
 
   /**
    * Get a value for a field config
-   * @param cfg Field config
+   * @param config Field config
    */
-  static #value(cfg: SchemaFieldConfig, subArray = false): unknown {
-    if (!subArray && cfg.array) {
-      return this.#array(cfg);
-    } else if (cfg.enum) {
-      return faker.helpers.arrayElement(cfg.enum.values);
+  static #value(config: SchemaFieldConfig, subArray = false): unknown {
+    if (!subArray && config.array) {
+      return this.#array(config);
+    } else if (config.enum) {
+      return faker.helpers.arrayElement(config.enum.values);
     } else {
 
-      const typ = cfg.type;
+      const typ = config.type;
 
       if (typ === Number) {
-        return this.#number(cfg);
+        return this.#number(config);
       } else if (typ === String) {
-        return this.#string(cfg);
+        return this.#string(config);
       } else if (typ === Date) {
-        return this.#date(cfg);
+        return this.#date(config);
       } else if (typ === Boolean) {
         return faker.datatype.boolean();
       } else if (SchemaRegistryIndex.has(typ)) {
@@ -189,14 +189,14 @@ export class SchemaFaker {
     const fields = SchemaRegistryIndex.get(cls).getFields(view);
     const out: Record<string, unknown> = {};
 
-    for (const [f, fieldConfig] of Object.entries(fields)) {
-      if (f === 'type' || f === 'id') { // Do not set primary fields
+    for (const [name, fieldConfig] of Object.entries(fields)) {
+      if (name === 'type' || name === 'id') { // Do not set primary fields
         continue;
       }
       if (fieldConfig.required?.active === false && (Math.random() < .5)) {
         continue;
       }
-      out[f] = this.#value(fieldConfig);
+      out[name] = this.#value(fieldConfig);
     }
 
     return BindUtil.bindSchema(cls, out, { view });