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

package/src/export_import/export.ts

@@ -4,7 +4,6 @@ import {
     EntityReference,
     getArrayValuesCount,
     getValueInPath,
-    ResolvedEntityCollection,
     ResolvedProperties,
     ResolvedProperty
 } from "@firecms/core";
@@ -14,37 +13,43 @@ interface Header {
     label: string;
 }
 
-export function downloadExport<M extends Record<string, any>>(data: Entity<M>[],
-                                                              additionalData: Record<string, any>[] | undefined,
-                                                              collection: ResolvedEntityCollection<M>,
-                                                              flattenArrays: boolean,
-                                                              additionalHeaders: string[] | undefined,
-                                                              exportType: "csv" | "json",
-                                                              dateExportType: "timestamp" | "string"
+export function downloadEntitiesExport<M extends Record<string, any>>(data: Entity<M>[],
+                                                                      additionalData: Record<string, any>[] | undefined,
+                                                                      properties: ResolvedProperties<M>,
+                                                                      propertiesOrder: string[] | undefined,
+                                                                      name: string,
+                                                                      flattenArrays: boolean,
+                                                                      additionalHeaders: string[] | undefined,
+                                                                      exportType: "csv" | "json",
+                                                                      dateExportType: "timestamp" | "string"
 ) {
 
-    console.debug("Downloading export", { dataLength: data.length, collection, exportType, dateExportType });
-    const properties = collection.properties;
+    console.debug("Downloading export", {
+        dataLength: data.length,
+        properties,
+        exportType,
+        dateExportType
+    });
 
     if (exportType === "csv") {
         const arrayValuesCount = flattenArrays ? getArrayValuesCount(data.map(d => d.values)) : {};
-        const headers = getExportHeaders(properties, additionalHeaders, arrayValuesCount);
-        const exportableData = getCSVExportableData(data, additionalData, properties, headers, dateExportType);
+        const headers = getExportHeaders(properties, propertiesOrder, additionalHeaders, arrayValuesCount);
+        const exportableData = getEntityCSVExportableData(data, additionalData, properties, headers, dateExportType);
         const headersData = entryToCSVRow(headers.map(h => h.label));
         const csvData = exportableData.map(entry => entryToCSVRow(entry));
-        downloadBlob([headersData, ...csvData], `${collection.name}.csv`, "text/csv");
+        downloadBlob([headersData, ...csvData], `${name}.csv`, "text/csv");
     } else {
-        const exportableData = getJsonExportableData(data, additionalData, properties, dateExportType);
+        const exportableData = getEntityJsonExportableData(data, additionalData, properties, dateExportType);
         const json = JSON.stringify(exportableData, null, 2);
-        downloadBlob([json], `${collection.name}.json`, "application/json");
+        downloadBlob([json], `${name}.json`, "application/json");
     }
 }
 
-export function getCSVExportableData(data: Entity<any>[],
-                                     additionalData: Record<string, any>[] | undefined,
-                                     properties: ResolvedProperties,
-                                     headers: Header[],
-                                     dateExportType: "timestamp" | "string"
+export function getEntityCSVExportableData(data: Entity<any>[],
+                                           additionalData: Record<string, any>[] | undefined,
+                                           properties: ResolvedProperties,
+                                           headers: Header[],
+                                           dateExportType: "timestamp" | "string"
 ) {
 
     const mergedData: any[] = data.map(e => ({
@@ -63,10 +68,10 @@ export function getCSVExportableData(data: Entity<any>[],
     });
 }
 
-export function getJsonExportableData(data: Entity<any>[],
-                                      additionalData: Record<string, any>[] | undefined,
-                                      properties: ResolvedProperties,
-                                      dateExportType: "timestamp" | "string"
+export function getEntityJsonExportableData(data: Entity<any>[],
+                                            additionalData: Record<string, any>[] | undefined,
+                                            properties: ResolvedProperties,
+                                            dateExportType: "timestamp" | "string"
 ) {
 
     const mergedData: any[] = data.map(e => ({
@@ -84,13 +89,18 @@ export function getJsonExportableData(data: Entity<any>[],
 }
 
 function getExportHeaders<M extends Record<string, any>>(properties: ResolvedProperties<M>,
+                                                         propertiesOrder: string[] | undefined,
                                                          additionalHeaders: string[] | undefined,
                                                          arrayValuesCount?: ArrayValuesCount): Header[] {
 
     const headers: Header[] = [
-        { label: "id", key: "id" },
-        ...Object.entries(properties)
-            .flatMap(([childKey, property]) => {
+        {
+            label: "id",
+            key: "id"
+        },
+        ...(propertiesOrder ?? Object.keys(properties))
+            .flatMap((childKey) => {
+                const property = properties[childKey];
                 if (arrayValuesCount && arrayValuesCount[childKey] > 1) {
                     return Array.from({ length: arrayValuesCount[childKey] },
                         (_, i) => getHeaders(property as ResolvedProperty, `${childKey}[${i}]`, ""))
@@ -102,7 +112,10 @@ function getExportHeaders<M extends Record<string, any>>(properties: ResolvedPro
     ];
 
     if (additionalHeaders) {
-        headers.push(...additionalHeaders.map(h => ({ label: h, key: h })));
+        headers.push(...additionalHeaders.map(h => ({
+            label: h,
+            key: h
+        })));
     }
 
     return headers;
@@ -121,7 +134,10 @@ function getHeaders(property: ResolvedProperty, propertyKey: string, prefix = ""
             .map(([childKey, p]) => getHeaders(p, childKey, currentKey))
             .flat();
     } else {
-        return [{ label: currentKey, key: currentKey }];
+        return [{
+            label: currentKey,
+            key: currentKey
+        }];
     }
 }
 

package/src/export_import/index.ts

@@ -0,0 +1,4 @@
+export * from "./export";
+export * from "./BasicExportAction";
+export * from "./ExportCollectionAction";
+export * from "./ImportCollectionAction";

package/src/hooks/useImportConfig.tsx

@@ -5,6 +5,7 @@ import { ImportConfig } from "../types";
 export const useImportConfig = (): ImportConfig => {
 
     const [inUse, setInUse] = useState<boolean>(false);
+    const [defaultValues, setDefaultValues] = useState<Record<string, any>>({});
     const [idColumn, setIdColumn] = useState<string | undefined>();
     const [importData, setImportData] = useState<object[]>([]);
     const [entities, setEntities] = useState<Entity<any>[]>([]);
@@ -27,5 +28,7 @@ export const useImportConfig = (): ImportConfig => {
         setHeadersMapping,
         originProperties,
         setOriginProperties,
+        defaultValues,
+        setDefaultValues
     };
 };

package/src/index.ts

@@ -3,3 +3,4 @@ export * from "./components";
 export * from "./types";
 export * from "./utils";
 export * from "./hooks";
+export * from "./export_import";

package/src/types/column_mapping.ts

@@ -26,11 +26,7 @@ export type ImportConfig = {
     headingsOrder: string[];
     setHeadingsOrder: React.Dispatch<React.SetStateAction<string[]>>;
 
-}
+    defaultValues: Record<string, any>;
+    setDefaultValues: React.Dispatch<React.SetStateAction<Record<string, any>>>;
 
-export type DataTypeMapping = {
-    from: DataType;
-    fromSubtype?: DataType;
-    to: DataType;
-    toSubtype?: DataType;
 }

package/src/useImportExportPlugin.tsx

@@ -19,7 +19,7 @@ export function useImportExportPlugin(props?: ImportExportPluginProps): FireCMSP
 
 export type ImportExportPluginProps = {
     exportAllowed?: (props: ExportAllowedParams) => boolean;
-    notAllowedView: React.ReactNode;
+    notAllowedView?: React.ReactNode;
     onAnalyticsEvent?: (event: string, params?: any) => void;
 }
 export type ExportAllowedParams = { collectionEntitiesCount: number, path: string, collection: EntityCollection };

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";