@firecms/schema_inference 3.0.0-canary.8 → 3.0.0-canary.80

package/src/collection_builder.ts

@@ -2,11 +2,10 @@ import {
     DataType,
     EnumValues,
     mergeDeep,
-    Properties,
+    Properties, PropertiesOrBuilders,
     Property,
     resolveEnumValues,
-    StringProperty,
-    unslugify
+    StringProperty
 } from "@firecms/core";
 import {
     InferencePropertyBuilderProps,
@@ -22,7 +21,10 @@ import { extractEnumFromValues } from "./util";
 
 export type InferenceTypeBuilder = (value: any) => DataType;
 
-export async function buildEntityPropertiesFromData(data: object[], getType: InferenceTypeBuilder): Promise<Properties> {
+export async function buildEntityPropertiesFromData(
+    data: object[],
+    getType: InferenceTypeBuilder
+): Promise<Properties> {
     const typesCount: TypesCountRecord = {};
     const valuesCount: ValuesCountRecord = {};
     if (data) {
@@ -31,15 +33,18 @@ export async function buildEntityPropertiesFromData(data: object[], getType: Inf
                 Object.entries(entry).forEach(([key, value]) => {
                     increaseMapTypeCount(typesCount, key, value, getType);
                     increaseValuesCount(valuesCount, key, value, getType);
-                })
+                });
             }
         });
     }
-    // console.log(util.inspect({ typesCount }, { showHidden: false, depth: null, colors: true }));
     return buildPropertiesFromCount(data.length, typesCount, valuesCount);
 }
 
-export function buildPropertyFromData(data: any[], property: Property, getType: InferenceTypeBuilder): Property {
+export function buildPropertyFromData(
+    data: any[],
+    property: Property,
+    getType: InferenceTypeBuilder
+): Property {
     const typesCount = {};
     const valuesCount: ValuesCountRecord = {};
     if (data) {
@@ -56,20 +61,33 @@ export function buildPropertyFromData(data: any[], property: Property, getType:
             enumValues: [...newEnumValues, ...enumValues]
         } as StringProperty;
     }
-    const generatedProperty = buildPropertyFromCount("inferred_prop", data.length, property.dataType, typesCount, valuesCount["inferred_prop"]);
+    const generatedProperty = buildPropertyFromCount(
+        "inferred_prop",
+        data.length,
+        property.dataType,
+        typesCount,
+        valuesCount["inferred_prop"]
+    );
     return mergeDeep(generatedProperty, property);
 }
 
-export function buildPropertiesOrder(properties: Properties<any>): string [] {
+export function buildPropertiesOrder(
+    properties: PropertiesOrBuilders,
+    propertiesOrder?: string[],
+    priorityKeys?: string[]
+): string[] {
+    const lowerCasePriorityKeys = (priorityKeys ?? []).map((key) => key.toLowerCase());
+
     function propOrder(s: string) {
         const k = s.toLowerCase();
+        if (lowerCasePriorityKeys.includes(k)) return 4;
         if (k === "title" || k === "name") return 3;
         if (k.includes("title") || k.includes("name")) return 2;
         if (k.includes("image") || k.includes("picture")) return 1;
         return 0;
     }
 
-    const keys = Object.keys(properties);
+    const keys = propertiesOrder ?? Object.keys(properties);
     keys.sort(); // alphabetically
     keys.sort((a, b) => {
         return propOrder(b) - propOrder(a);
@@ -83,7 +101,12 @@ export function buildPropertiesOrder(properties: Properties<any>): string [] {
  * @param fieldValue
  * @param getType
  */
-function increaseTypeCount(type: DataType, typesCount: TypesCount, fieldValue: any, getType: InferenceTypeBuilder) {
+function increaseTypeCount(
+    type: DataType,
+    typesCount: TypesCount,
+    fieldValue: any,
+    getType: InferenceTypeBuilder
+) {
     if (type === "map") {
         if (fieldValue) {
             let mapTypesCount = typesCount[type];
@@ -93,7 +116,7 @@ function increaseTypeCount(type: DataType, typesCount: TypesCount, fieldValue: a
             }
             Object.entries(fieldValue).forEach(([key, value]) => {
                 increaseMapTypeCount(mapTypesCount as TypesCountRecord, key, value, getType);
-            })
+            });
         }
     } else if (type === "array") {
         let arrayTypesCount = typesCount[type];
@@ -102,9 +125,22 @@ function increaseTypeCount(type: DataType, typesCount: TypesCount, fieldValue: a
             typesCount[type] = arrayTypesCount;
         }
         if (fieldValue && Array.isArray(fieldValue) && fieldValue.length > 0) {
-            const arrayType = getMostProbableTypeInArray(fieldValue, getType); // get type of first element
-            if (!arrayTypesCount[arrayType]) (arrayTypesCount[arrayType] as number) = 1;
-            else (arrayTypesCount[arrayType] as number)++;
+            const arrayType = getMostProbableTypeInArray(fieldValue, getType);
+            if (arrayType === "map") {
+                let mapTypesCount = arrayTypesCount[arrayType];
+                if (!mapTypesCount) {
+                    mapTypesCount = {};
+                }
+                fieldValue.forEach((value) => {
+                    Object.entries(value).forEach(([key, v]) =>
+                        increaseMapTypeCount(mapTypesCount, key, v, getType)
+                    );
+                });
+                arrayTypesCount[arrayType] = mapTypesCount;
+            } else {
+                if (!arrayTypesCount[arrayType]) arrayTypesCount[arrayType] = 1;
+                else (arrayTypesCount[arrayType] as number)++;
+            }
         }
     } else {
         if (!typesCount[type]) typesCount[type] = 1;
@@ -124,7 +160,8 @@ function increaseMapTypeCount(
         typesCountRecord[key] = typesCount;
     }
 
-    if (fieldValue != null) { // Check that fieldValue is not null or undefined before proceeding
+    if (fieldValue != null) {
+        // Check that fieldValue is not null or undefined before proceeding
         const type = getType(fieldValue);
         increaseTypeCount(type, typesCount, fieldValue, getType);
     }
@@ -136,7 +173,6 @@ function increaseValuesCount(
     fieldValue: any,
     getType: InferenceTypeBuilder
 ) {
-
     const dataType = getType(fieldValue);
 
     let valuesRecord: {
@@ -160,13 +196,15 @@ function increaseValuesCount(
             valuesRecord.map = mapValuesRecord;
         }
         if (fieldValue)
-            Object.entries(fieldValue).forEach(([key, value]) => increaseValuesCount(mapValuesRecord as ValuesCountRecord, key, value, getType))
+            Object.entries(fieldValue).forEach(([key, value]) =>
+                increaseValuesCount(mapValuesRecord as ValuesCountRecord, key, value, getType)
+            );
     } else if (dataType === "array") {
         if (Array.isArray(fieldValue)) {
             fieldValue.forEach((value) => {
                 valuesRecord.values.push(value);
                 valuesRecord.valuesCount.set(value, (valuesRecord.valuesCount.get(value) ?? 0) + 1);
-            })
+            });
         }
     } else {
         if (fieldValue) {
@@ -174,7 +212,6 @@ function increaseValuesCount(
             valuesRecord.valuesCount.set(fieldValue, (valuesRecord.valuesCount.get(fieldValue) ?? 0) + 1);
         }
     }
-
 }
 
 function getHighestTypesCount(typesCount: TypesCount): number {
@@ -204,7 +241,7 @@ function getHighestRecordCount(record: TypesCountRecord): number {
 
 function getMostProbableType(typesCount: TypesCount): DataType {
     let highestCount = -1;
-    let probableType: DataType = "string"; //default
+    let probableType: DataType = "string"; // default
     Object.entries(typesCount).forEach(([type, count]) => {
         let countValue;
         if (type === "map") {
@@ -222,16 +259,21 @@ function getMostProbableType(typesCount: TypesCount): DataType {
     return probableType;
 }
 
-function buildPropertyFromCount(key: string, totalDocsCount: number, mostProbableType: DataType, typesCount: TypesCount, valuesResult?: ValuesCountEntry): Property {
+function buildPropertyFromCount(
+    key: string,
+    totalDocsCount: number,
+    mostProbableType: DataType,
+    typesCount: TypesCount,
+    valuesResult?: ValuesCountEntry
+): Property {
     let title: string | undefined;
 
     if (key) {
-        title = unslugify(key);
+        title = formatString(key.toLowerCase());
     }
 
     let result: Property | undefined = undefined;
     if (mostProbableType === "map") {
-
         const highVariability = checkTypesCountHighVariability(typesCount);
         if (highVariability) {
             result = {
@@ -241,7 +283,11 @@ function buildPropertyFromCount(key: string, totalDocsCount: number, mostProbabl
                 properties: {}
             };
         }
-        const properties = buildPropertiesFromCount(totalDocsCount, typesCount.map as TypesCountRecord, valuesResult ? valuesResult.mapValues : undefined);
+        const properties = buildPropertiesFromCount(
+            totalDocsCount,
+            typesCount.map as TypesCountRecord,
+            valuesResult ? valuesResult.mapValues : undefined
+        );
         result = {
             dataType: "map",
             name: title,
@@ -250,13 +296,20 @@ function buildPropertyFromCount(key: string, totalDocsCount: number, mostProbabl
     } else if (mostProbableType === "array") {
         const arrayTypesCount = typesCount.array as TypesCount;
         const arrayMostProbableType = getMostProbableType(arrayTypesCount);
-        const of = buildPropertyFromCount(key, totalDocsCount, arrayMostProbableType, arrayTypesCount, valuesResult);
+        const of = buildPropertyFromCount(
+            key,
+            totalDocsCount,
+            arrayMostProbableType,
+            arrayTypesCount,
+            valuesResult
+        );
         result = {
             dataType: "array",
             name: title,
             of
         };
     }
+
     if (!result) {
         const propertyProps: InferencePropertyBuilderProps = {
             name: key,
@@ -289,19 +342,28 @@ function buildPropertyFromCount(key: string, totalDocsCount: number, mostProbabl
     };
 }
 
-function buildPropertiesFromCount(totalDocsCount: number, typesCountRecord: TypesCountRecord, valuesCountRecord?: ValuesCountRecord): Properties {
+function buildPropertiesFromCount(
+    totalDocsCount: number,
+    typesCountRecord: TypesCountRecord,
+    valuesCountRecord?: ValuesCountRecord
+): Properties {
     const res: Properties = {};
     Object.entries(typesCountRecord).forEach(([key, typesCount]) => {
         const mostProbableType = getMostProbableType(typesCount);
-        res[key] = buildPropertyFromCount(key, totalDocsCount, mostProbableType, typesCount, valuesCountRecord ? valuesCountRecord[key] : undefined);
-    })
+        res[key] = buildPropertyFromCount(
+            key,
+            totalDocsCount,
+            mostProbableType,
+            typesCount,
+            valuesCountRecord ? valuesCountRecord[key] : undefined
+        );
+    });
     return res;
 }
 
 function countMaxDocumentsUnder(typesCount: TypesCount) {
     let count = 0;
     Object.entries(typesCount).forEach(([type, value]) => {
-        // console.log(util.inspect({ type, value }, { showHidden: false, depth: null, colors: true }));
         if (typeof value === "object") {
             count = Math.max(count, countMaxDocumentsUnder(value as TypesCountRecord));
         } else {
@@ -311,7 +373,10 @@ function countMaxDocumentsUnder(typesCount: TypesCount) {
     return count;
 }
 
-function getMostProbableTypeInArray(array: any[], getType: InferenceTypeBuilder): DataType {
+function getMostProbableTypeInArray(
+    array: any[],
+    getType: InferenceTypeBuilder
+): DataType {
     let typesCount: TypesCount = {};
     array.forEach((value) => {
         increaseTypeCount(getType(value), typesCount, value, getType);
@@ -322,13 +387,37 @@ function getMostProbableTypeInArray(array: any[], getType: InferenceTypeBuilder)
 function checkTypesCountHighVariability(typesCount: TypesCount) {
     const maxCount = countMaxDocumentsUnder(typesCount);
     let keysWithFewValues = 0;
-    Object.entries(typesCount.map ?? {})
-        .forEach(([key, value]) => {
-            const count = countMaxDocumentsUnder(value);
-            if (count < maxCount / 3) {
-                keysWithFewValues++;
-            }
-        });
+    Object.entries(typesCount.map ?? {}).forEach(([key, value]) => {
+        const count = countMaxDocumentsUnder(value);
+        if (count < maxCount / 3) {
+            keysWithFewValues++;
+        }
+    });
     return keysWithFewValues / Object.entries(typesCount.map ?? {}).length > 0.5;
 }
 
+function formatString(input: string): string {
+    const normalized = input
+        .replace(/[_\-]+/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase();
+
+    // Split the normalized string into words
+    const words = normalized.split(" ");
+
+    // Capitalize the first letter of each word and join them with a space
+    const formatted = words
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+
+    return formatted;
+}
+
+export function inferTypeFromValue(value: any): DataType {
+    if (typeof value === "string") return "string";
+    if (typeof value === "number") return "number";
+    if (typeof value === "boolean") return "boolean";
+    if (Array.isArray(value)) return "array";
+    if (typeof value === "object") return "map";
+    return "string";
+}

package/src/strings.ts

@@ -1,5 +1,5 @@
 import { ValuesCountEntry } from "./types";
-import { DocumentReference } from "firebase/firestore";
+import { DocumentReference } from "@firebase/firestore";
 
 export function findCommonInitialStringInPath(valuesCount?: ValuesCountEntry) {