@firecms/data_import_export 3.0.0-canary.42 → 3.0.0-canary.43

package/src/utils/data.ts

@@ -1,41 +1,44 @@
-import { DataType, Entity, EntityReference, getPropertyInPath, Properties } from "@firecms/core";
+import {
+    Entity,
+    EntityReference,
+    getPropertyInPath,
+    isPropertyBuilder,
+    mergeDeep,
+    Properties,
+    Property,
+    PropertyOrBuilder,
+    ResolvedProperty,
+    resolveProperty
+} from "@firecms/core";
 import { unflattenObject } from "./file_to_json";
-
-type DataTypeMapping = {
-    from: DataType;
-    fromSubtype?: DataType;
-    to: DataType;
-    toSubtype?: DataType;
-}
+import { getIn } from "@firecms/formex";
+import { inferTypeFromValue } from "@firecms/schema_inference";
 
 export function convertDataToEntity(data: Record<any, any>,
                                     idColumn: string | undefined,
                                     headersMapping: Record<string, string | null>,
                                     properties: Properties,
-                                    propertiesMapping: Record<string, DataTypeMapping>,
-                                    path: string): Entity<any> {
+                                    path: string,
+                                    defaultValues: Record<string, any>): Entity<any> {
     const flatObject = flattenEntry(data);
     if (idColumn)
         delete flatObject[idColumn];
     const mappedKeysObject = Object.entries(flatObject)
         .map(([key, value]) => {
-            const mappedKey = headersMapping[key] ?? key;
+            const mappedKey = getIn(headersMapping, key) ?? key;
 
             const mappedProperty = getPropertyInPath(properties, mappedKey);
-            if (!mappedProperty)
+            if (!mappedProperty) {
                 return {};
-
-            const propertyMapping = propertiesMapping[mappedKey];
-            let valueResult = value;
-            if (propertyMapping) {
-                valueResult = processValueMapping(value, propertyMapping);
             }
+            const processedValue = processValueMapping(value, mappedProperty);
             return ({
-                [mappedKey]: valueResult
+                [mappedKey]: processedValue
             });
         })
         .reduce((acc, curr) => ({ ...acc, ...curr }), {});
-    const values = unflattenObject(mappedKeysObject);
+
+    const values = mergeDeep(defaultValues ?? {}, unflattenObject(mappedKeysObject));
     let id = idColumn ? data[idColumn] : undefined;
     if (typeof id === "string") {
         id = id.trim();
@@ -60,7 +63,7 @@ export function flattenEntry(obj: any, parent = ""): any {
     return Object.keys(obj).reduce((acc, key) => {
         const prefixedKey = parent ? `${parent}.${key}` : key;
 
-        if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) {
+        if (typeof obj[key] === "object" && !(obj[key] instanceof Date) && obj[key] !== null && !Array.isArray(obj[key])) {
             Object.assign(acc, flattenEntry(obj[key], prefixedKey));
         } else {
             // @ts-ignore
@@ -71,116 +74,24 @@ export function flattenEntry(obj: any, parent = ""): any {
     }, {});
 }
 
-// export function convertDataEntryValue({
-//                                           key,
-//                                           fullKey,
-//                                           value,
-//                                           idColumn,
-//                                           headersMapping,
-//                                           properties,
-//                                           propertiesMapping
-//                                       }: {
-//     key?: string,
-//     fullKey: string,
-//     value: any,
-//     idColumn?: string,
-//     headersMapping: Record<string, string | null>,
-//     properties: Properties,
-//     propertiesMapping: Record<string, DataTypeMapping>
-// }): any {
-//
-//     if (value === undefined) return value;
-//     if (value === null) return value;
-//
-//     if (Array.isArray(value)) {
-//         const mappedKey = headersMapping[fullKey] || fullKey;
-//         const valueMapping = propertiesMapping[mappedKey];
-//         return processValueMapping(value, valueMapping);
-//         // return value.map(v => convertDataEntryValue({ value: v, fullKey, idColumn, headersMapping, propertiesMapping }));
-//     } else if (typeof value === "object") {
-//         return convertDataObjectValue({
-//             key,
-//             fullKey,
-//             value,
-//             idColumn,
-//             headersMapping,
-//             properties,
-//             propertiesMapping
-//         });
-//     } else {
-//         const mappedKey = headersMapping[fullKey] || fullKey;
-//         const valueMapping = propertiesMapping[mappedKey];
-//         return processValueMapping(value, valueMapping);
-//     }
-// }
+export function processValueMapping(value: any, property?: PropertyOrBuilder): any {
+    if (value === null) return null;
 
-// export function convertDataObjectValue({
-//                                            key,
-//                                            fullKey,
-//                                            value,
-//                                            idColumn,
-//                                            headersMapping,
-//                                            properties,
-//                                            propertiesMapping
-//                                        }: {
-//     key?: string,
-//     fullKey?: string,
-//     value: object,
-//     idColumn?: string,
-//     headersMapping: Record<string, string | null>,
-//     properties: Properties,
-//     propertiesMapping: Record<string, DataTypeMapping>
-// }): object {
-//
-//     if (value instanceof Date) {
-//         const mappedKey = fullKey ? headersMapping[fullKey] || fullKey : undefined;
-//         const valueMapping = mappedKey ? propertiesMapping[mappedKey] : undefined;
-//         return processValueMapping(value, valueMapping);
-//     }
-//
-//     return Object.entries(value)
-//         .map(([childKey, childValue]) => {
-//             const childFullKey = fullKey ? `${fullKey}.${childKey}` : childKey;
-//             const mappedKey = headersMapping[childFullKey] ?? childFullKey;
-//             const mappedKeyLastPart = mappedKey.split(".").slice(-1)[0];
-//             const property = getPropertyInPath(properties, mappedKey);
-//             // if (!property) {
-//             //     console.log("ppp", { properties, mappedKey,  })
-//             //     return {};
-//             // }
-//             return ({
-//                 [mappedKeyLastPart]: convertDataEntryValue({
-//                     key: childKey,
-//                     fullKey: childFullKey,
-//                     value: childValue,
-//                     idColumn,
-//                     headersMapping,
-//                     properties,
-//                     propertiesMapping
-//                 })
-//             });
-//         })
-//         .reduce((acc, curr) => ({ ...acc, ...curr }), {});
-// }
+    if (property === undefined) return value;
+    const usedProperty: ResolvedProperty | null = resolveProperty({
+        propertyOrBuilder: property,
+        propertyValue: value
+    })
+    if (usedProperty === null) return value;
+    const from = inferTypeFromValue(value);
+    const to = usedProperty.dataType;
 
-export function processValueMapping(value: any, valueMapping?: DataTypeMapping): any {
-    if (valueMapping === undefined) return value;
-    const {
-        from,
-        to
-    } = valueMapping;
-    if (from === "array" && to === "array" && valueMapping.fromSubtype && valueMapping.toSubtype && Array.isArray(value)) {
-        return value.map(v => processValueMapping(v, {
-            from: valueMapping.fromSubtype!,
-            to: valueMapping.toSubtype!
-        }));
+    if (from === "array" && to === "array" && Array.isArray(value) && usedProperty.of && !isPropertyBuilder(usedProperty.of as PropertyOrBuilder)) {
+        return value.map(v => processValueMapping(v, usedProperty.of as Property));
     } else if (from === "string" && to === "number" && typeof value === "string") {
         return Number(value);
-    } else if (from === "string" && to === "array" && valueMapping.toSubtype && typeof value === "string") {
-        return value.split(",").map((v: string) => processValueMapping(v, {
-            from: "string",
-            to: valueMapping.toSubtype!
-        }));
+    } else if (from === "string" && to === "array" && typeof value === "string" && usedProperty.of && !isPropertyBuilder(usedProperty.of as PropertyOrBuilder)) {
+        return value.split(",").map((v: string) => processValueMapping(v, usedProperty.of));
     } else if (from === "string" && to === "boolean") {
         return value === "true";
     } else if (from === "number" && to === "boolean") {

package/src/utils/get_properties_mapping.ts

@@ -1,59 +1,63 @@
-import { DataType, getPropertyInPath, Properties, Property } from "@firecms/core";
-import { DataTypeMapping } from "../types";
-
-export function getPropertiesMapping(originProperties: Properties, newProperties: Properties): Record<string, DataTypeMapping> {
-
-    function updateMapping(properties: Record<string, Property>, namespace?: string): Record<string, DataTypeMapping> {
-
-        const dataMapping: Record<string, DataTypeMapping> = {};
-
-        Object.keys(properties).forEach((key) => {
-
-            const currentKey = namespace ? `${namespace}.${key}` : key;
-
-            const property = getPropertyInPath(properties, key) as Property;
-            const inferredProperty = getPropertyInPath(originProperties, currentKey) as Property;
-
-            if (property) {
-                if (property.dataType === "map" && property.properties) {
-                    const nestedMapping = updateMapping(property.properties as Record<string, Property>, currentKey);
-                    Object.keys(nestedMapping).forEach((nestedKey) => {
-                        dataMapping[`${currentKey}.${nestedKey}`] = nestedMapping[nestedKey];
-                    });
-                    return;
-                }
-
-                if (inferredProperty) {
-
-                    const from = inferredProperty.dataType;
-                    const to = property.dataType;
-                    let fromSubtype: DataType | undefined;
-                    let toSubtype: DataType | undefined;
-
-                    if (property.dataType === "array" && property.of) {
-                        toSubtype = (property.of as Property).dataType;
-                    }
-
-                    if (inferredProperty?.dataType === "array" && inferredProperty?.of) {
-                        fromSubtype = (inferredProperty.of as Property).dataType;
-                    }
-
-                    if (from !== to || fromSubtype !== toSubtype) {
-                        dataMapping[key] = {
-                            from,
-                            to,
-                            fromSubtype,
-                            toSubtype
-                        };
-                    }
-                }
-
-            }
-
-        });
-
-        return dataMapping;
-    }
-
-    return updateMapping(newProperties);
-}
+// import { DataType, getPropertyInPath, Properties, Property } from "@firecms/core";
+// import { DataTypeMapping } from "../types";
+//
+// export function getPropertiesMapping(originProperties: Properties,
+//                                      newProperties: Properties,
+//                                      headersMapping: Record<string, string | null>): Record<string, DataTypeMapping> {
+//
+//     function updateMapping(properties: Record<string, Property>, namespace?: string): Record<string, DataTypeMapping> {
+//
+//         const dataMapping: Record<string, DataTypeMapping> = {};
+//
+//         Object.keys(properties).forEach((key) => {
+//
+//             const currentKey = namespace ? `${namespace}.${key}` : key;
+//
+//             const property = getPropertyInPath(properties, key) as Property;
+//             // reverse lookup
+//             const mappedKey = Object.entries(headersMapping).find(([_, value]) => value === currentKey)?.[0];
+//             const inferredProperty = mappedKey ? getPropertyInPath(originProperties, mappedKey) as Property : null;
+//
+//             if (property) {
+//                 if (property.dataType === "map" && property.properties) {
+//                     const nestedMapping = updateMapping(property.properties as Record<string, Property>, currentKey);
+//                     Object.keys(nestedMapping).forEach((nestedKey) => {
+//                         dataMapping[`${currentKey}.${nestedKey}`] = nestedMapping[nestedKey];
+//                     });
+//                     return;
+//                 }
+//
+//                 if (inferredProperty) {
+//
+//                     const from = inferredProperty.dataType;
+//                     const to = property.dataType;
+//                     let fromSubtype: DataType | undefined;
+//                     let toSubtype: DataType | undefined;
+//
+//                     if (property.dataType === "array" && property.of) {
+//                         toSubtype = (property.of as Property).dataType;
+//                     }
+//
+//                     if (inferredProperty?.dataType === "array" && inferredProperty?.of) {
+//                         fromSubtype = (inferredProperty.of as Property).dataType;
+//                     }
+//
+//                     if (from !== to || fromSubtype !== toSubtype) {
+//                         dataMapping[currentKey] = {
+//                             from,
+//                             to,
+//                             fromSubtype,
+//                             toSubtype
+//                         };
+//                     }
+//                 }
+//
+//             }
+//
+//         });
+//
+//         return dataMapping;
+//     }
+//
+//     return updateMapping(newProperties);
+// }

package/src/utils/index.ts

@@ -1,4 +1,3 @@
 export * from "./file_to_json";
 export * from "./data";
 export * from "./get_import_inference_type";
-export * from "./get_properties_mapping";