fuse-importer 0.27.0 → 0.30.0

package/lib/esm/Importer/contexts/ImporterContextProvider.js

@@ -55,19 +55,14 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import Fuse from "fuse.js";
 import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { FieldTypes, } from "../../types";
 import { FuseApi } from "../common/FuseApi";
 import { getCustomTheme, theme } from "../common/theme";
 import { getColumnType, verifyDuplicateValue } from "../common/utils";
-export var fusejsOptions = {
-    includeScore: true,
-    threshold: 0.35,
-};
 var ImporterContext = createContext({});
 export var ImporterContextProvider = function (_a) {
-    var templateSlug = _a.templateSlug, initialRecords = _a.initialRecords, apiToken = _a.apiToken, children = _a.children, options = _a.options, onSubmit = _a.onSubmit, onClose = _a.onClose, formatRecord = _a.formatRecord, onValidateRecord = _a.onValidateRecord, dynamicColumns = _a.dynamicColumns;
+    var templateSlug = _a.templateSlug, initialRecords = _a.initialRecords, apiToken = _a.apiToken, children = _a.children, options = _a.options, onSubmit = _a.onSubmit, onClose = _a.onClose, formatRecord = _a.formatRecord, onValidateRecord = _a.onValidateRecord, dynamicColumns = _a.dynamicColumns, customActions = _a.customActions;
     var _b = useState(initialRecords ? 2 : 0), currentStepIndex = _b[0], setCurrentStepIndex = _b[1];
     var _c = useState(0), matcherSubstep = _c[0], setMatcherSubstep = _c[1];
     var _d = useState(null), templateError = _d[0], setTemplateError = _d[1];
@@ -76,20 +71,51 @@ export var ImporterContextProvider = function (_a) {
     var _g = useState(null), uploadedData = _g[0], setUploadedData = _g[1];
     var _h = useState(null), organization = _h[0], setOrganization = _h[1];
     var _j = useState(null), previewFirstTime = _j[0], setPreviewFirstTime = _j[1];
-    var _k = useState({
+    var _k = useState(null), headersMappings = _k[0], setHeadersMappings = _k[1];
+    var _l = useState({
         theme: theme,
         logoURL: null,
-    }), style = _k[0], setStyle = _k[1];
-    var _l = useState(null), templateHeaderMatchings = _l[0], setTemplateHeaderMatchings = _l[1];
-    var _m = useState(null), enumFieldValueMatchings = _m[0], setEnumFieldValueMatchings = _m[1];
-    var _o = useState(null), uploadedDataEnumFieldValues = _o[0], setUploadedDataEnumFieldValues = _o[1];
-    var _p = useState([]), selectedRows = _p[0], setSelectedRows = _p[1];
+    }), style = _l[0], setStyle = _l[1];
+    var _m = useState(null), templateHeaderMatchings = _m[0], setTemplateHeaderMatchings = _m[1];
+    var _o = useState({}), enumFieldValueMatchings = _o[0], setEnumFieldValueMatchings = _o[1];
+    var _p = useState(null), uploadedDataEnumFieldValues = _p[0], setUploadedDataEnumFieldValues = _p[1];
+    var _q = useState([]), selectedRows = _q[0], setSelectedRows = _q[1];
     var isUsingManualImport = useRef(false);
-    var _q = useState(0), headerRowIndex = _q[0], setHeaderRowIndex = _q[1];
+    var _r = useState(0), headerRowIndex = _r[0], setHeaderRowIndex = _r[1];
+    var _s = useState(false), headerMappingsLoaded = _s[0], setHeaderMappingsLoaded = _s[1];
+    var _t = useState(false), valueMappingsLoaded = _t[0], setValueMappingsLoaded = _t[1];
     var fuseApi = useMemo(function () { return new FuseApi(options.env, apiToken); }, [
         options.env,
         apiToken,
     ]);
+    var fetchColumnMappings = function (userDynamicColumns) { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fuseApi.post("/api/v1/importer/templates/".concat(templateSlug, "/column_mappings"), {
+                        file_headers: uploadedDataHeaders,
+                        dynamic_columns: userDynamicColumns,
+                    })];
+                case 1:
+                    mappings = (_a.sent()).data.mappings;
+                    return [2 /*return*/, mappings];
+            }
+        });
+    }); };
+    var fetchValueMappings = function (_uploadedDataEnumFieldValues, userDynamicValues) { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fuseApi.post("/api/v1/importer/templates/".concat(templateSlug, "/value_mappings"), {
+                        file_values: _uploadedDataEnumFieldValues,
+                        dynamic_values: userDynamicValues,
+                    })];
+                case 1:
+                    mappings = (_a.sent()).data.mappings;
+                    return [2 /*return*/, mappings];
+            }
+        });
+    }); };
     var uploadedDataHeaders = useMemo(function () {
         var _a;
         if (!uploadedData)
@@ -104,23 +130,109 @@ export var ImporterContextProvider = function (_a) {
             return typeof ud === "number" ? ud.toString() : ud;
         });
     }, [uploadedData, headerRowIndex]);
+    var userDynamicColumns = dynamicColumns.map(function (value) { return value.label; });
+    // use the API to match selected headers to the template
+    var loadHeaderMappings = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setHeaderMappingsLoaded(false);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetchColumnMappings(userDynamicColumns)];
+                case 2:
+                    mappings = _a.sent();
+                    setHeadersMappings(mappings);
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_1 = _a.sent();
+                    setHeadersMappings([]);
+                    console.error("Error occurred while fetching header mappings", e_1);
+                    return [3 /*break*/, 4];
+                case 4:
+                    setHeaderMappingsLoaded(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    useEffect(function () {
+        (function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (uploadedDataHeaders) {
+                    loadHeaderMappings();
+                }
+                return [2 /*return*/];
+            });
+        }); })();
+    }, [uploadedDataHeaders]);
+    // Values mappings for enum columns
+    var loadValueMappings = function (_uploadedDataEnumFieldValues) { return __awaiter(void 0, void 0, void 0, function () {
+        var dynamicValues, mappings, e_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setValueMappingsLoaded(false);
+                    if (!(!!_uploadedDataEnumFieldValues &&
+                        Object.keys(_uploadedDataEnumFieldValues).length > 0)) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    dynamicValues = userDynamicColumns.reduce(function (acc, column) {
+                        var _a;
+                        var values = (_a = templateHeaders.find(function (header) { return header.label === column; })) === null || _a === void 0 ? void 0 : _a.values;
+                        if (values) {
+                            acc[column] = values;
+                        }
+                        return acc;
+                    }, {});
+                    return [4 /*yield*/, fetchValueMappings(_uploadedDataEnumFieldValues, dynamicValues)];
+                case 2:
+                    mappings = _a.sent();
+                    setEnumFieldValueMatchings(mappings);
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_2 = _a.sent();
+                    setEnumFieldValueMatchings({});
+                    console.error("Error occurred while fetching value mappings", e_2);
+                    return [3 /*break*/, 4];
+                case 4:
+                    setValueMappingsLoaded(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     useEffect(function () {
         var setHeadersFromDataset = function () {
             var _templateHeaderMatchings = {};
-            var fuse = new Fuse(uploadedDataHeaders, fusejsOptions);
             templateHeaders.forEach(function (templateHeader, _index) {
-                var _a;
-                var fuseResults = fuse.search(templateHeader.label);
-                _templateHeaderMatchings[templateHeader.label] = (_a = fuseResults[0]) === null || _a === void 0 ? void 0 : _a.item;
+                var mappedHeader = headersMappings.find(function (headerMapping) {
+                    var matchedColumn = Object.values(headerMapping)[0];
+                    if (matchedColumn) {
+                        return (matchedColumn.toLowerCase() === templateHeader.label.toLowerCase());
+                    }
+                    else {
+                        return false;
+                    }
+                });
+                if (mappedHeader) {
+                    _templateHeaderMatchings[templateHeader.label] = Object.keys(mappedHeader)[0];
+                }
+                else {
+                    _templateHeaderMatchings[templateHeader.label] = null;
+                }
             });
             setTemplateHeaderMatchings(_templateHeaderMatchings);
         };
-        if (uploadedDataHeaders) {
+        if (uploadedDataHeaders && headersMappings) {
             setHeadersFromDataset();
         }
-    }, [uploadedDataHeaders]);
+    }, [uploadedDataHeaders, headersMappings]);
     useEffect(function () {
-        if (!templateHeaderMatchings || !uploadedDataHeaders)
+        if (!templateHeaderMatchings ||
+            !uploadedDataHeaders ||
+            !headerMappingsLoaded)
             return;
         var _uploadedDataEnumFieldValues = {};
         var templateLabels = Object.keys(templateHeaderMatchings);
@@ -142,7 +254,13 @@ export var ImporterContextProvider = function (_a) {
             });
         });
         setUploadedDataEnumFieldValues(_uploadedDataEnumFieldValues);
-    }, [templateHeaderMatchings, uploadedDataHeaders]);
+        var valueLimitPerEnumField = Math.ceil(40 / enumFieldsLabels.length);
+        var enumFieldsLabelsLimited = {};
+        Object.keys(_uploadedDataEnumFieldValues).forEach(function (key) {
+            enumFieldsLabelsLimited[key] = _uploadedDataEnumFieldValues[key].slice(0, valueLimitPerEnumField);
+        });
+        loadValueMappings(enumFieldsLabelsLimited);
+    }, [headerMappingsLoaded, matcherSubstep]);
     useEffect(function () {
         (function () { return __awaiter(void 0, void 0, void 0, function () {
             var _a, organization_1, columns_1, importer_style_preferences, integrations_1, preview_first_time, error_1, errorMsg;
@@ -188,6 +306,11 @@ export var ImporterContextProvider = function (_a) {
     var resetImport = function () {
         setUploadedData(null);
         setTemplateHeaderMatchings(null);
+        setHeadersMappings(null);
+        setEnumFieldValueMatchings({});
+        setUploadedDataEnumFieldValues(null);
+        setSelectedRows([]);
+        setHeaderRowIndex(0);
     };
     var resetImporterWhenUsingManualImport = function () {
         setCurrentStepIndex(0);
@@ -207,6 +330,7 @@ export var ImporterContextProvider = function (_a) {
         initialRecords: initialRecords,
         currentStepIndex: currentStepIndex,
         templateHeaders: templateHeaders,
+        userDynamicColumns: userDynamicColumns,
         enumFieldValueMatchings: enumFieldValueMatchings,
         templateHeaderMatchings: templateHeaderMatchings,
         uploadedDataEnumFieldValues: uploadedDataEnumFieldValues,
@@ -226,6 +350,7 @@ export var ImporterContextProvider = function (_a) {
         headerRowIndex: headerRowIndex,
         setHeaderRowIndex: setHeaderRowIndex,
         setUploadedData: setUploadedData,
+        setHeadersMappings: setHeadersMappings,
         formatRecord: formatRecord,
         setCurrentStepIndex: setCurrentStepIndex,
         setEnumFieldValueMatchings: setEnumFieldValueMatchings,
@@ -241,6 +366,10 @@ export var ImporterContextProvider = function (_a) {
         isUsingManualImport: isUsingManualImport,
         resetImporterWhenUsingManualImport: resetImporterWhenUsingManualImport,
         manualDataImportSelected: manualDataImportSelected,
+        customActions: customActions,
+        headerMappingsLoaded: headerMappingsLoaded,
+        valueMappingsLoaded: valueMappingsLoaded,
+        headersMappings: headersMappings,
     };
     return (_jsx(ImporterContext.Provider, __assign({ value: value }, { children: children })));
 };

package/lib/esm/Importer/data/index.d.ts

@@ -1,4 +1,4 @@
-import { Field, FieldTypes, FormatRecord, Record, RecordDataSet, TemplateHeader } from "../../types";
+import { Field, FieldTypes, FormatRecord, Record, RecordDataSet, TemplateHeader, TransformedRecord } from "../../types";
 import { EnumFieldValueMatchings, HeaderMatchings } from "../contexts/ImporterContextProvider";
 export declare const addEmptyRows: (data: Record[], fields: Field[]) => (Record | {
     _meta: {
@@ -6,8 +6,11 @@ export declare const addEmptyRows: (data: Record[], fields: Field[]) => (Record
         rowIndex: number;
     };
 })[];
-export declare const addMeta: (record: any, index: number, uploadedRow?: any) => Record;
-export declare const recordListToDataSet: (data: Record[], fields: Field[]) => RecordDataSet;
+export declare const addMeta: (record: any, index: number, uploadedRow?: any, transformedRow?: TransformedRecord) => Record;
+export declare const recordListToDataSet: (data: Record[], fields: Field[], withTransformations?: boolean) => {
+    isDatasetTransformed: boolean;
+    dataSet: RecordDataSet;
+};
 type transformToRecordsArgs = {
     templateHeaderMatchings: HeaderMatchings;
     enumFieldValueMatchings: EnumFieldValueMatchings;
@@ -45,6 +48,7 @@ type GetReviewDataSetArgs = {
     fields: Field[];
 };
 export declare const getReviewDataSet: ({ records, fields }: GetReviewDataSetArgs) => {
+    isDatasetTransformed: boolean;
     initialDataSet: {
         [x: string]: Record;
     };

package/lib/esm/Importer/data/index.js

@@ -23,8 +23,7 @@ import { FieldTypes, } from "../../types";
 import { parseValue } from "../common/Spreadsheet/common";
 var MINIMUM_ROW_COUNT = 20;
 var getRowId = function (index) {
-    var uniqueTimestamp = new Date().getTime();
-    return "r".concat(index, "-").concat(uniqueTimestamp);
+    return index.toString();
 };
 export var addEmptyRows = function (data, fields) {
     var emptyRecord = fields.reduce(function (obj, f) {
@@ -37,23 +36,51 @@ export var addEmptyRows = function (data, fields) {
         } })); });
     return __spreadArray(__spreadArray([], data, true), newData, true);
 };
-export var addMeta = function (record, index, uploadedRow) {
+export var addMeta = function (record, index, uploadedRow, transformedRow) {
     var _a;
     if (uploadedRow === void 0) { uploadedRow = null; }
+    if (transformedRow === void 0) { transformedRow = {}; }
     var rId = getRowId(index);
     var meta = (_a = record._meta) !== null && _a !== void 0 ? _a : {};
-    return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, touched: false, uploadedRow: uploadedRow }) });
+    return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, uploadedRow: uploadedRow, transformedRow: transformedRow }) });
 };
-export var recordListToDataSet = function (data, fields) {
+export var recordListToDataSet = function (data, fields, withTransformations) {
+    if (withTransformations === void 0) { withTransformations = true; }
+    var fieldWithTransformations = fields.filter(function (field) { var _a; return ((_a = field === null || field === void 0 ? void 0 : field.transformations) === null || _a === void 0 ? void 0 : _a.length) > 0; });
     var initialData = data;
     if (data.length < MINIMUM_ROW_COUNT) {
         initialData = addEmptyRows(data, fields);
     }
-    return initialData.reduce(function (dataSet, record, i) {
-        var recordWithMeta = addMeta(record, i);
+    var isDatasetTransformed = false;
+    var res = initialData.reduce(function (dataSet, record, i) {
+        var transformedRecord = {};
+        if (withTransformations && fieldWithTransformations.length > 0) {
+            transformedRecord = transformRecord({
+                record: record,
+                fields: fieldWithTransformations,
+            });
+        }
+        if (JSON.stringify(transformedRecord) !== "{}")
+            isDatasetTransformed = true;
+        var recordWithMeta = addMeta(record, i, undefined, transformedRecord);
         dataSet[recordWithMeta._meta.id] = recordWithMeta;
         return dataSet;
     }, {});
+    return { isDatasetTransformed: isDatasetTransformed, dataSet: res };
+};
+var compareFormattedRecord = function (originalRecord, formattedRecord) {
+    var comparisonResult = {};
+    for (var key in formattedRecord) {
+        if (formattedRecord.hasOwnProperty(key)) {
+            if (formattedRecord[key] !== originalRecord[key]) {
+                comparisonResult[key] = {
+                    original: originalRecord[key],
+                    transformed: formattedRecord[key],
+                };
+            }
+        }
+    }
+    return comparisonResult;
 };
 export var transformToRecords = function (_a) {
     var templateHeaderMatchings = _a.templateHeaderMatchings, enumFieldValueMatchings = _a.enumFieldValueMatchings, templateHeaders = _a.templateHeaders, uploadedDataHeaders = _a.uploadedDataHeaders, uploadedData = _a.uploadedData, formatRecord = _a.formatRecord;
@@ -83,14 +110,21 @@ export var transformToRecords = function (_a) {
                 return;
             record[key] = parseValue(FieldTypes[header.column_type], value, enumSet);
         });
-        return formatRecord ? formatRecord(record) : record;
+        if (formatRecord) {
+            var formattedRecord = formatRecord(record);
+            var comparisonResult = compareFormattedRecord(record, formattedRecord);
+            record._meta.transformedRow = comparisonResult;
+            return formattedRecord;
+        }
+        return record;
     };
     return uploadedData.map(getRecord);
 };
 export var getPreviewDataSet = function (_a) {
     var uploadedData = _a.uploadedData;
     var rowLen = 0;
-    for (var i = 0; i < uploadedData.length; i++)
+    var previewSize = Math.min(100, uploadedData.length);
+    for (var i = 0; i < previewSize; i++)
         rowLen = Math.max(rowLen, uploadedData[i].length);
     var fields = new Array(rowLen).fill(null).map(function (_, i) {
         var key = String.fromCharCode(65 + i);
@@ -102,14 +136,16 @@ export var getPreviewDataSet = function (_a) {
         };
     });
     var getInitialDataSet = function () {
-        var data = uploadedData.map(function (row, index) {
+        var data = uploadedData
+            .slice(0, previewSize)
+            .map(function (row, index) {
             var entry = addMeta({}, index);
             fields.forEach(function (field, index) {
                 entry[field.name] = row[index];
             });
             return entry;
         });
-        return recordListToDataSet(data, fields);
+        return recordListToDataSet(data, fields).dataSet;
     };
     return { fields: fields, initialDataSet: getInitialDataSet() };
 };
@@ -129,14 +165,7 @@ export var getTemplateFields = function (_a) {
 export var getReviewDataSet = function (_a) {
     var _b;
     var records = _a.records, fields = _a.fields;
-    for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
-        var record = records_1[_i];
-        transformRecord({
-            record: record,
-            fields: fields,
-        });
-    }
-    var baseInitialDataSet = recordListToDataSet(addEmptyRows(records, fields), fields);
+    var _c = recordListToDataSet(addEmptyRows(records, fields), fields), isDatasetTransformed = _c.isDatasetTransformed, baseInitialDataSet = _c.dataSet;
     var highestRowIndex = 0;
     Object.keys(baseInitialDataSet).forEach(function (key) {
         var record = baseInitialDataSet[key];
@@ -146,5 +175,5 @@ export var getReviewDataSet = function (_a) {
     });
     var emptyRowAtBottom = addMeta({}, highestRowIndex + 1);
     var initialDataSet = __assign(__assign({}, baseInitialDataSet), (_b = {}, _b[emptyRowAtBottom._meta.id] = emptyRowAtBottom, _b));
-    return { initialDataSet: initialDataSet };
+    return { isDatasetTransformed: isDatasetTransformed, initialDataSet: initialDataSet };
 };

package/lib/esm/Importer/hooks/useExportDataToFile.d.ts

@@ -0,0 +1,5 @@
+import { RecordDataSet } from "../../types";
+import { ExportDataType } from "../Review/ReviewContextProvider";
+export declare const useExportDataToFile: () => {
+    onExport: (dataSet: RecordDataSet, dataType: ExportDataType) => void;
+};

package/lib/esm/Importer/hooks/useExportDataToFile.js

@@ -0,0 +1,54 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useCallback } from "react";
+import Papa from "papaparse";
+import { useImporterContext } from "../contexts/ImporterContextProvider";
+function downloadCsv(data, fileName) {
+    var blob = new Blob([data], { type: "text/csv;charset=utf-8;" });
+    var link = document.createElement("a");
+    link.href = URL.createObjectURL(blob);
+    link.download = fileName;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+function csvExport(data) {
+    var valuesWithQuotesWhenNecessary = data.map(function (obj) {
+        var newObj = {};
+        for (var key in obj) {
+            var value = obj[key];
+            newObj[key] =
+                typeof value === "string" && value.includes(",") ? "\"".concat(value, "\"") : value;
+        }
+        return newObj;
+    });
+    var csv = Papa.unparse(valuesWithQuotesWhenNecessary);
+    downloadCsv(csv, "export.csv");
+}
+export var useExportDataToFile = function () {
+    var selectedRows = useImporterContext().selectedRows;
+    var onExport = useCallback(function (dataSet, dataType) {
+        if (!dataSet)
+            return;
+        var dataSetValues = Object.values(dataSet);
+        if (dataType === "csv") {
+            var valuesWithoutMeta = dataSetValues.map(function (_a) {
+                var _meta = _a._meta, rest = __rest(_a, ["_meta"]);
+                return rest;
+            });
+            csvExport(valuesWithoutMeta);
+        }
+    }, [selectedRows]);
+    return {
+        onExport: onExport,
+    };
+};

package/lib/esm/Importer/hooks/useSubmitToServer.d.ts

@@ -0,0 +1,7 @@
+import { AppResponse, RecordDataSet } from "../../types";
+export declare const useSubmitToServer: (setHasTransformedRecords: any) => {
+    appResponse: AppResponse;
+    isSubmitting: boolean;
+    onSubmitToServer: (dataSet: RecordDataSet, afterSubmitCallback: (dataSet: RecordDataSet) => void) => Promise<void>;
+    importWasSuccessful: boolean;
+};