feat!: update snake_case schema properties to camelCase (#190)

Author: Anemy

README.md

@@ -92,7 +92,7 @@ below accordingly).
         "count": 4,               // 4 documents counted with _id
         "type": "Number",         // the type of _id is `Number`
         "probability": 1,         // all documents had an _id field
-        "has_duplicates": false,  // therefore no duplicates
+        "hasDuplicates": false,  // therefore no duplicates
         "types": [                // an array of Type objects, @see `./lib/types/`
           {
             "name": "Number",     // name of the type
@@ -118,7 +118,7 @@ below accordingly).
           "Number",
           "Undefined"             // for convenience, we treat Undefined as its own type
         ],
-        "has_duplicates": false,   // there were no duplicate values
+        "hasDuplicates": false,   // there were no duplicate values
         "types": [
           {
             "name": "Boolean",

src/schema-analyzer.ts

@@ -1,5 +1,4 @@
 
-/* eslint-disable camelcase */
 import Reservoir from 'reservoir';
 import type {
   Document,
@@ -52,8 +51,8 @@ export type BaseSchemaType = {
   bsonType: string;
 
   // As `values` is from a sample reservoir this isn't a true check for duplicates/uniqueness.
-  // We cannot compute `unique` and `has_duplicates` when `storeValues` is false.
-  has_duplicates?: boolean;
+  // We cannot compute `unique` and `hasDuplicates` when `storeValues` is false.
+  hasDuplicates?: boolean;
   unique?: number;
 }
 
@@ -69,8 +68,8 @@ export type PrimitiveSchemaType = BaseSchemaType & {
 export type ArraySchemaType = BaseSchemaType & {
   name: 'Array';
   lengths: number[];
-  average_length: number;
-  total_count: number;
+  averageLength: number;
+  totalCount: number;
   // eslint-disable-next-line no-use-before-define
   types: SchemaType[];
 }
@@ -91,7 +90,7 @@ export type SchemaField = {
   path: string[];
   type: string | string[];
   probability: number;
-  has_duplicates: boolean;
+  hasDuplicates: boolean;
   types: SchemaType[];
 };
 
@@ -259,26 +258,26 @@ function computeUniqueForType(type: SchemaAnalysisType) {
 
 /**
  * Final pass through the result to add missing information:
- *   - Compute `probability`, `unique`, `has_duplicates` and
- *     `average_length` fields.
+ *   - Compute `probability`, `unique`, `hasDuplicates` and
+ *     `averageLength` fields.
  *   - Add `Undefined` pseudo-types.
  *   - Collapse `type` arrays to single string if length 1.
  *   - Turn fields and types objects into arrays to conform with original
  *     schema parser.
  */
 function finalizeSchema(schemaAnalysis: SchemaAnalysisRoot): SchemaField[] {
   function finalizeArrayFieldProperties(type: SchemaAnalysisArrayType) {
-    const total_count = Object.values(type.types)
+    const totalCount = Object.values(type.types)
       .map((v: any) => v.count)
       .reduce((p, c) => p + c, 0);
 
-    const types = finalizeSchemaFieldTypes(type.types, total_count);
+    const types = finalizeSchemaFieldTypes(type.types, totalCount);
 
     return {
       types,
-      total_count,
+      totalCount,
       lengths: type.lengths,
-      average_length: total_count / type.lengths.length
+      averageLength: totalCount / type.lengths.length
     };
   }
 
@@ -292,7 +291,7 @@ function finalizeSchema(schemaAnalysis: SchemaAnalysisRoot): SchemaField[] {
         count: type.count,
         probability: type.count / parentCount,
         unique,
-        has_duplicates: computeHasDuplicatesForType(type, unique),
+        hasDuplicates: computeHasDuplicatesForType(type, unique),
         values: isNullType(type) ? undefined : type.values,
         bsonType: type.bsonType, // Note: `Object` is replaced with `Document`.
         ...(isArrayType(type) ? finalizeArrayFieldProperties(type) : {}),
@@ -312,7 +311,7 @@ function finalizeSchema(schemaAnalysis: SchemaAnalysisRoot): SchemaField[] {
           name: 'Undefined',
           bsonType: 'Undefined',
           unique: undefinedCount > 1 ? 0 : 1,
-          has_duplicates: undefinedCount > 1,
+          hasDuplicates: undefinedCount > 1,
           path: field.path,
           count: undefinedCount,
           probability: undefinedCount / parentCount
@@ -325,7 +324,7 @@ function finalizeSchema(schemaAnalysis: SchemaAnalysisRoot): SchemaField[] {
         count: field.count,
         type: fieldTypes.length === 1 ? fieldTypes[0].name : fieldTypes.map((v: SchemaType) => v.name), // Or one value or array.
         probability: field.count / parentCount,
-        has_duplicates: !!fieldTypes.find((v: SchemaType) => v.has_duplicates),
+        hasDuplicates: !!fieldTypes.find((v: SchemaType) => v.hasDuplicates),
         types: fieldTypes
       };
     }).sort(fieldComparator);

test/array-object-types.test.ts

@@ -69,7 +69,7 @@ describe('arrays and objects as type (INT-203 restructuring)', function() {
     });
 
     it('should return the total count of all containing values', function() {
-      assert.equal((arr as ArraySchemaType).total_count, 8);
+      assert.equal((arr as ArraySchemaType).totalCount, 8);
     });
 
     it('should return the type distribution inside an array', function() {

test/basic-embedded-array.test.ts

@@ -31,7 +31,7 @@ describe('basic embedded array', function() {
   });
 
   it('should have an average length of 1.5 for followingIds', function() {
-    assert.equal(followingIds.average_length, 1.5);
+    assert.equal(followingIds.averageLength, 1.5);
   });
 
   it('should have a sum of probability for followingIds of 1', function() {

test/basic-unique.test.ts

@@ -4,7 +4,7 @@ import bson from 'bson';
 import getSchema from '../src';
 import type { Schema, PrimitiveSchemaType } from '../src/schema-analyzer';
 
-describe('has_duplicates', function() {
+describe('hasDuplicates', function() {
   const docs: {
     num: number;
     str: string;
@@ -22,7 +22,7 @@ describe('has_duplicates', function() {
   });
 
   it('should not have duplicates', function() {
-    assert.equal(schema.fields.find(v => v.name === 'num')?.has_duplicates, false);
+    assert.equal(schema.fields.find(v => v.name === 'num')?.hasDuplicates, false);
   });
 
   it('should have 10000 number values for the `num` field', function() {
@@ -76,7 +76,7 @@ describe('unique', function() {
   });
 
   it('should not have duplicates for `_id`', function() {
-    assert.equal(schema.fields.find(v => v.name === '_id')?.has_duplicates, false);
+    assert.equal(schema.fields.find(v => v.name === '_id')?.hasDuplicates, false);
   });
 
   it('should have count of 2 for `registered`', function() {
@@ -104,10 +104,10 @@ describe('unique', function() {
   });
 
   it('should not have duplicate values for b', function() {
-    assert.equal(schema.fields.find(v => v.name === 'b')?.has_duplicates, false);
+    assert.equal(schema.fields.find(v => v.name === 'b')?.hasDuplicates, false);
   });
 
   it('should have duplicates for `registered`', function() {
-    assert.equal(schema.fields.find(v => v.name === 'registered')?.has_duplicates, true);
+    assert.equal(schema.fields.find(v => v.name === 'registered')?.hasDuplicates, true);
   });
 });