@rebasepro/cms 0.17.3 → 0.18.1

package/src/data_import/utils/data.ts

@@ -1,181 +0,0 @@
-import { getPropertyInPath } from "../../util";
-import { Entity, EntityReference, CollectionRegistryController, Properties, Property, Vector } from "@rebasepro/types";
-import { AuthController, AdminCollection } from "@rebasepro/cms-types";
-import { isPropertyBuilder } from "@rebasepro/common";
-import { unflattenObject } from "./transforms";
-import { getIn } from "@rebasepro/forms";
-import { inferTypeFromValue } from "@rebasepro/inference";
-import { isPrototypePollutingKey, mergeDeep } from "@rebasepro/utils";
-
-export function convertDataToEntity(authController: AuthController,
-    navigation: CollectionRegistryController,
-    data: Record<any, any>,
-    idColumn: string | undefined,
-    headersMapping: Record<string, string | null>,
-    properties: Properties,
-    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 = (getIn(headersMapping, key) as string | undefined) ?? key;
-
-            const mappedProperty = getPropertyInPath(properties, mappedKey);
-            if (!mappedProperty) {
-                return {};
-            }
-            const processedValue = processValueMapping(authController, value, navigation, mappedProperty);
-            return ({
-                [mappedKey]: processedValue
-            });
-        })
-        .reduce((acc, curr) => ({ ...acc,
-...curr }), {});
-
-    const values = mergeDeep(defaultValues ?? {}, unflattenObject(mappedKeysObject));
-    let id = idColumn ? data[idColumn] : undefined;
-    if (typeof id === "string") {
-        id = id.trim();
-    } else if (typeof id === "number") {
-        id = id.toString();
-    } else if (typeof id === "boolean") {
-        id = id.toString();
-    } else if (id instanceof Date) {
-        id = id.toISOString();
-    } else if (id && "toString" in id) {
-        id = id.toString();
-    }
-
-    return {
-        id,
-        values,
-        path: path
-    };
-}
-
-export function flattenEntry(obj: Record<string, unknown>, parent = ""): Record<string, unknown> {
-    return Object.keys(obj).reduce<Record<string, unknown>>((acc, key) => {
-        // Keys come from the uploaded file, so `acc[key] = …` is the class-22
-        // primitive when the key is `__proto__`; refuse the column instead.
-        if (isPrototypePollutingKey(key)) {
-            console.warn(`Skipping column "${key}": a header may not reach the prototype chain`);
-            return acc;
-        }
-        const prefixedKey = parent ? `${parent}.${key}` : key;
-
-        if (typeof obj[key] === "object" && !(obj[key] instanceof Date) && obj[key] !== null && !Array.isArray(obj[key])) {
-            Object.assign(acc, flattenEntry(obj[key] as Record<string, unknown>, prefixedKey));
-        } else {
-            acc[prefixedKey] = obj[key];
-        }
-
-        return acc;
-    }, {});
-}
-
-export function processValueMapping(authController: AuthController, value: any, navigation: CollectionRegistryController, property?: Property): any {
-    if (value === null) return null;
-
-    if (property === undefined) return value;
-    const usedProperty: Property | null = property;
-    if (usedProperty === null) return value;
-    const from = inferTypeFromValue(value);
-    const to = usedProperty.type;
-
-    if (to === "vector") {
-        if (value && typeof value === "object" && "value" in value && Array.isArray(value.value)) {
-            return new Vector(value.value);
-        } else if (Array.isArray(value)) {
-            return new Vector(value.map(Number));
-        } else if (typeof value === "string") {
-            let cleaned = value.trim();
-            if (cleaned.startsWith("[") && cleaned.endsWith("]")) {
-                cleaned = cleaned.slice(1, -1);
-            }
-            if (cleaned === "") return null;
-            return new Vector(cleaned.split(",").map(v => {
-                const num = Number(v.trim());
-                return isNaN(num) ? 0 : num;
-            }));
-        }
-        return value;
-    }
-
-    if (from === "array" && to === "array" && Array.isArray(value) && usedProperty.of && !Array.isArray(usedProperty.of) && !isPropertyBuilder(usedProperty.of)) {
-        return value.map(v => processValueMapping(authController, v, navigation, usedProperty.of as Property));
-    } else if (from === "string" && to === "number" && typeof value === "string") {
-        // `Number("")` is 0, so a blank cell used to import as a real zero — a
-        // price of nothing rather than a price nobody filled in — and `Number`
-        // of anything unreadable imported as NaN. Both are absent values, and
-        // saying so lets the importer's own validation see them. The `vector`
-        // branch above already draws the same distinction.
-        const trimmed = value.trim();
-        if (trimmed === "") return null;
-        const num = Number(trimmed);
-        return Number.isNaN(num) ? null : num;
-    } else if (from === "string" && to === "array" && typeof value === "string" && usedProperty.of && !Array.isArray(usedProperty.of) && !isPropertyBuilder(usedProperty.of)) {
-        return value.split(",").map((v: string) => processValueMapping(authController, v, navigation, usedProperty.of as Property));
-    } else if (from === "string" && to === "boolean") {
-        return value === "true";
-    } else if (from === "number" && to === "boolean") {
-        return value === 1;
-    } else if (from === "boolean" && to === "number") {
-        return value ? 1 : 0;
-    } else if (from === "boolean" && to === "string") {
-        return value ? "true" : "false";
-    } else if (from === "number" && to === "string" && typeof value === "number") {
-        return value.toString();
-    } else if (from === "string" && to === "array" && typeof value === "string") {
-        return value.split(",").map((v: string) => v.trim());
-    } else if (from === "string" && to === "date" && typeof value === "string") {
-        try {
-            return new Date(value);
-        } catch (e) {
-            return value;
-        }
-    } else if (value instanceof Date && to === "string") {
-        return value.toISOString();
-    } else if (from === "number" && to === "date" && typeof value === "number") {
-        try {
-            return new Date(value);
-        } catch (e) {
-            return value;
-        }
-    } else if (from === "string" && to === "reference" && typeof value === "string") {
-        // Parse optional database name in format: database_name:::path/to/entity
-        // or simple format: path/to/entity
-        let databaseId: string | undefined = undefined;
-        let referencePath = value;
-
-        if (value.includes(":::")) {
-            const [dbName, pathPart] = value.split(":::");
-            if (dbName && dbName !== "(default)") {
-                databaseId = dbName;
-            }
-            referencePath = pathPart;
-        }
-
-        // split value into path and entityId (entityId is the last part of the path, after the last /)
-        const path = referencePath.split("/").slice(0, -1).join("/");
-        const entityId = referencePath.split("/").slice(-1)[0];
-
-        // If no explicit database was provided in the string, try to get it from the collection
-        if (databaseId === undefined) {
-            const targetCollection: AdminCollection<any> | undefined = navigation.getCollection(path);
-            databaseId = targetCollection?.databaseId;
-        }
-
-        return new EntityReference({ id: entityId,
-path,
-databaseId });
-
-    } else if (from === to) {
-        return value;
-    } else if (from === "array" && to === "string" && Array.isArray(value)) {
-        return value.join(",");
-    }
-
-    return value;
-}

package/src/data_import/utils/file_headers.ts

@@ -1,14 +0,0 @@
-import type { Worksheet } from "exceljs";
-
-/**
- * Extract column headers from the first row of an ExcelJS worksheet.
- * Returns an array of header strings in column order.
- */
-export function getWorksheetHeaders(worksheet: Worksheet): string[] {
-    const headers: string[] = [];
-    const headerRow = worksheet.getRow(1);
-    headerRow.eachCell({ includeEmpty: false }, (cell, colNumber) => {
-        headers[colNumber - 1] = cell.text ?? `Column${colNumber}`;
-    });
-    return headers.filter(Boolean);
-}

package/src/data_import/utils/file_to_json.ts

@@ -1,149 +0,0 @@
-import { getWorksheetHeaders } from "./file_headers";
-import { mapJsonParse, unflattenObject } from "./transforms";
-import { parseCsvToObjects } from "./csv";
-import { isPrototypePollutingKey } from "@rebasepro/utils";
-
-type ConversionResult = {
-    data: object[];
-    propertiesOrder: string[]
-}
-
-/**
- * ExcelJS, fetched the first time somebody actually opens a workbook.
- *
- * It was a top-level `import ExcelJS from "exceljs"`, and that one line put
- * 940 kB of spreadsheet reader into the admin's entry chunk — preloaded on the
- * login screen, before anyone has authenticated, let alone clicked Import.
- * `CollectionViewActions` lazy-loads the import and export actions and says so
- * in a comment, but the package's own barrel (`src/index.ts` re-exports
- * `./data_import`) puts this module back in the entry's static graph, so the
- * `lazy()` bought nothing. A static import inside a module the barrel reaches
- * is eager no matter what the component above it does; the only thing that
- * makes a dependency lazy is importing it lazily, here.
- */
-type ExcelJsModule = typeof import("exceljs");
-
-let excelJsModule: Promise<ExcelJsModule> | undefined;
-
-function loadExcelJs(): Promise<ExcelJsModule> {
-    // exceljs is CommonJS, so the namespace a bundler hands back wraps the real
-    // module under `default`. Native ESM (and the type declarations) put the
-    // members at the top level. Accept either.
-    excelJsModule ??= import("exceljs").then(mod => (mod as { default?: ExcelJsModule }).default ?? mod);
-    return excelJsModule;
-}
-
-/**
- * Whether this file is delimited text rather than a workbook.
- *
- * Browsers report `text/csv`, `application/csv` or nothing at all for the same
- * `.csv`, so the extension is the reliable half of the test.
- */
-function isCsvFile(file: File): boolean {
-    const name = (file.name ?? "").toLowerCase();
-    if (name.endsWith(".csv") || name.endsWith(".tsv")) return true;
-    return file.type === "text/csv" || file.type === "application/csv";
-}
-
-/** Turn the parsed cells of one sheet/file into the entity-shaped rows the import maps. */
-function toImportRows(rows: Array<Record<string, unknown>>): object[] {
-    return rows.map(mapJsonParse).map(unflattenObject);
-}
-
-export function convertFileToJson(file: File): Promise<ConversionResult> {
-    return new Promise((resolve, reject) => {
-        if (isCsvFile(file)) {
-            // Not the ExcelJS branch: `workbook.xlsx.load` is a zip reader, and
-            // every CSV — the format this admin exports by default — died on it
-            // with "Can't find end of central directory : is this a zip file ?".
-            console.debug("Converting CSV file to JSON", file.name);
-            const reader = new FileReader();
-            reader.onload = function (e) {
-                try {
-                    const { headers, data } = parseCsvToObjects(e.target?.result as string);
-                    if (headers.length === 0) {
-                        reject(new Error("The CSV file is empty"));
-                        return;
-                    }
-                    resolve({
-                        data: toImportRows(data),
-                        propertiesOrder: headers
-                    });
-                } catch (err) {
-                    console.error("Error parsing CSV file", err);
-                    reject(err);
-                }
-            };
-            reader.onerror = () => reject(reader.error ?? new Error("Could not read the file"));
-            // Explicit UTF-8: the pre-ExcelJS implementation passed
-            // `codepage: 65001` for the same reason, and the browser's default
-            // guess mangles accented and CJK text.
-            reader.readAsText(file, "utf-8");
-        } else if (file.type === "application/json") {
-            console.debug("Converting JSON file to JSON", file.name);
-            const reader = new FileReader();
-            reader.onload = function (e) {
-                try {
-                    const data = e.target?.result as string;
-                    const jsonData = JSON.parse(data);
-                    if (!Array.isArray(jsonData)) {
-                        reject(new Error("JSON file should contain an array of objects"));
-                    } else {
-                        const propertiesOrder = jsonData.length > 0 ? Object.keys(jsonData[0]) : [];
-                        resolve({
-                            data: jsonData,
-                            propertiesOrder
-                        });
-                    }
-                } catch (e) {
-                    console.error("Error parsing JSON file", e);
-                    reject(e);
-                }
-            };
-            reader.readAsText(file);
-        } else {
-            console.debug("Converting Excel file to JSON", file.name);
-            const reader = new FileReader();
-            reader.onload = async function (e) {
-                try {
-                    const buffer = e.target?.result as ArrayBuffer;
-                    const ExcelJS = await loadExcelJs();
-                    const workbook = new ExcelJS.Workbook();
-                    await workbook.xlsx.load(buffer);
-                    const worksheet = workbook.worksheets[0];
-                    if (!worksheet) {
-                        reject(new Error("No worksheets found in file"));
-                        return;
-                    }
-
-                    const headers = getWorksheetHeaders(worksheet);
-
-                    // Convert rows to JSON objects (skip header row)
-                    const parsedData: Array<Record<string, any>> = [];
-                    worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
-                        if (rowNumber === 1) return;
-                        const obj: Record<string, any> = {};
-                        row.eachCell({ includeEmpty: false }, (cell, colNumber) => {
-                            const header = headers[colNumber - 1];
-                            // A `__proto__` header would be the prototype setter
-                            // here rather than a column; refused, as in `csv.ts`.
-                            if (header && !isPrototypePollutingKey(header)) {
-                                obj[header] = cell.value;
-                            }
-                        });
-                        parsedData.push(obj);
-                    });
-
-                    resolve({
-                        data: toImportRows(parsedData),
-                        propertiesOrder: headers
-                    });
-                } catch (err) {
-                    console.error("Error parsing Excel file", err);
-                    reject(err);
-                }
-            };
-            reader.readAsArrayBuffer(file);
-        }
-    });
-}

package/src/data_import/utils/get_import_inference_type.ts

@@ -1,33 +0,0 @@
-import { DataType } from "@rebasepro/types";
-
-export function getInferenceType(value: any): DataType {
-    // `typeof null === "object"`, so a null or empty CSV cell used to fall past
-    // every check and land on "map" — an empty cell described as a nested object.
-    // `inferTypeFromValue` in @rebasepro/inference already answers "string" here;
-    // the two entry points into inference have to agree.
-    if (value === null || value === undefined)
-        return "string";
-    if (typeof value === "number")
-        return "number";
-    else if (typeof value === "string")
-        return "string";
-    else if (typeof value === "boolean")
-        return "boolean";
-    else if (value instanceof Date)
-        return "date";
-    else if (Array.isArray(value))
-        return "array";
-    return "map";
-}
-
-
-function isUnixTimestamp(num: number): boolean {
-    const numString = num.toString();
-    // check if the number has 13 digits
-    const isLengthValid = numString.length === 13;
-
-    // check if it falls in the expected Unix timestamp range (from 1970 to 2100)
-    const isInRange = num >= 0 && num <= 4102444800000;
-
-    return isLengthValid && isInRange;
-}

package/src/data_import/utils/get_properties_mapping.ts

@@ -1,67 +0,0 @@
-// import {
-//     type,
-//     getPropertyInPath
-// } from "@rebasepro/app";
-import { Properties, Property } from "@rebasepro/types";
-// import { typeMapping } from "@rebasepro/types";
-//
-// export function getPropertiesMapping(originProperties: Properties,
-//                                      newProperties: Properties,
-//                                      headersMapping: Record<string, string | null>): Record<string, typeMapping> {
-//
-//     function updateMapping(properties: Record<string, Property>, namespace?: string): Record<string, typeMapping> {
-//
-//         const dataMapping: Record<string, typeMapping> = {};
-//
-//         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.type === "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.type;
-//                     const to = property.type;
-//                     let fromSubtype: type | undefined;
-//                     let toSubtype: type | undefined;
-//
-//                     if (property.type === "array" && property.of) {
-//                         toSubtype = (property.of as Property).type;
-//                     }
-//
-//                     if (inferredProperty?.type === "array" && inferredProperty?.of) {
-//                         fromSubtype = (inferredProperty.of as Property).type;
-//                     }
-//
-//                     if (from !== to || fromSubtype !== toSubtype) {
-//                         dataMapping[currentKey] = {
-//                             from,
-//                             to,
-//                             fromSubtype,
-//                             toSubtype
-//                         };
-//                     }
-//                 }
-//
-//             }
-//
-//         });
-//
-//         return dataMapping;
-//     }
-//
-//     return updateMapping(newProperties);
-// }

package/src/data_import/utils/index.ts

@@ -1,5 +0,0 @@
-export * from "./file_to_json";
-export * from "./csv";
-export * from "./save_entities";
-export * from "./data";
-export * from "./get_import_inference_type";

package/src/data_import/utils/save_entities.ts

@@ -1,138 +0,0 @@
-import { CollectionAccessor, Entity, RebaseData } from "@rebasepro/types";
-
-/** Rows written per request, and per transaction where the data source has one. */
-export const IMPORT_BATCH_SIZE = 25;
-
-/**
- * An import failure that says where it stopped.
- *
- * "Error saving data / null value in column "sku" violates not-null constraint"
- * on a ten-thousand-row import named no row, and the Retry button restarted at
- * zero — where the rows already written now conflicted, so it could never
- * succeed. Both halves of that are what this carries.
- */
-export interface ImportSaveError extends Error {
-    /** Rows written and confirmed before the failure. Where a retry resumes. */
-    committed: number;
-    /** Index of the first row that was not written, 0-based. */
-    failedFrom: number;
-    /** Index after the last row of the batch that was not written. */
-    failedTo: number;
-}
-
-/** The row a bulk write takes: the values, with the chosen id as a column. */
-function toBulkRow(entity: Partial<Entity<any>>): Record<string, unknown> {
-    const values = { ...(entity.values ?? {}) } as Record<string, unknown>;
-    if (entity.id !== undefined && entity.id !== null && entity.id !== "") {
-        // Exactly what single-row `create(values, id)` puts on the wire.
-        values.id = entity.id;
-    }
-    return values;
-}
-
-function isBulkUnsupported(error: unknown): boolean {
-    if ((error as { code?: string })?.code === "BULK_UNSUPPORTED") return true;
-    const message = (error as Error)?.message ?? "";
-    return /bulk writes are not supported|does not support bulk/i.test(message);
-}
-
-function isConflict(error: unknown): boolean {
-    const status = (error as { status?: number; statusCode?: number })?.status
-        ?? (error as { statusCode?: number })?.statusCode;
-    if (status === 409) return true;
-    const code = (error as { code?: string })?.code;
-    return code === "CONFLICT" || code === "23505";
-}
-
-/**
- * Write one batch, all-or-nothing wherever the data source can.
- *
- * `POST /<collection>/bulk` validates every row before the transaction opens,
- * names a failure by row index, and takes the `upsert` flag the preview screen
- * promises — none of which one `create` per row inside a `Promise.all` could
- * offer, since `Promise.all` does not cancel its siblings and every request was
- * its own transaction.
- */
-async function writeBatch(accessor: CollectionAccessor,
-    batch: Partial<Entity<any>>[],
-    bulkUnsupported: { current: boolean },
-    written: { count: number }): Promise<void> {
-
-    if (accessor.createMany && !bulkUnsupported.current) {
-        try {
-            await accessor.createMany(batch.map(toBulkRow), { upsert: true });
-            written.count = batch.length;
-            return;
-        } catch (e) {
-            if (!isBulkUnsupported(e)) throw e;
-            // A data source without bulk writes: remember it, so the failed
-            // round trip is not paid again on every later batch.
-            bulkUnsupported.current = true;
-        }
-    }
-
-    // Sequential, not `Promise.all`: a rejected write does not cancel its
-    // siblings, so a parallel batch commits an indeterminate subset of itself
-    // and nobody can say which rows landed.
-    for (const entity of batch) {
-        try {
-            await accessor.create(entity.values ?? {}, entity.id);
-        } catch (e) {
-            // Without `/bulk` there is no upsert, so the preview's promise is
-            // honoured the only way left: a row that collided on an id the user
-            // supplied is overwritten. A row with no id had nothing to collide
-            // on, and every other failure is still a failure.
-            if (entity.id === undefined || !isConflict(e)) throw e;
-            await accessor.update(entity.id, entity.values ?? {});
-        }
-        written.count++;
-    }
-}
-
-/**
- * Write imported entities in batches, reporting what was committed.
- *
- * Resumable on purpose: a failure at row 4 000 leaves rows 1–3 999 in the table
- * whatever this does, so the only useful thing to report is where to carry on
- * from. `offset` is that point — the Retry button passes back the `committed`
- * count of the error it is retrying, instead of starting from zero and
- * conflicting on every row that already exists.
- *
- * @throws {ImportSaveError} naming the rows that were not written.
- */
-export async function saveImportedEntities(dataClient: RebaseData,
-    path: string,
-    data: Partial<Entity<any>>[],
-    {
-        offset = 0,
-        batchSize = IMPORT_BATCH_SIZE,
-        onBatchCommitted = () => undefined,
-        bulkUnsupported = { current: false }
-    }: {
-        offset?: number;
-        batchSize?: number;
-        onBatchCommitted?: (rowsWritten: number) => void;
-        bulkUnsupported?: { current: boolean };
-    } = {}): Promise<void> {
-
-    console.debug("Saving imported data", offset, batchSize);
-
-    const accessor = dataClient.collection(path);
-
-    for (let start = offset; start < data.length; start += batchSize) {
-        const batch = data.slice(start, start + batchSize);
-        const written = { count: 0 };
-        try {
-            await writeBatch(accessor, batch, bulkUnsupported, written);
-        } catch (e) {
-            throw Object.assign(e as Error, {
-                committed: start + written.count,
-                failedFrom: start + written.count,
-                failedTo: start + batch.length
-            }) as ImportSaveError;
-        }
-        onBatchCommitted(start + batch.length);
-    }
-
-    onBatchCommitted(data.length);
-}

package/src/data_import/utils/transforms.ts

@@ -1,70 +0,0 @@
-import { isPrototypePollutingKey, pathTraversesPrototype } from "@rebasepro/utils";
-
-/**
- * Take an object with keys of type `address.street`, `address.city` and
- * convert it to an object with nested objects like `{ address: { street: ..., city: ... } }`
- *
- * Keys here are the **header row of an uploaded file**, so they are attacker
- * data. `res["__proto__"] = …` is the prototype setter rather than an own
- * property, so a column named `__proto__.polluted` walked out of the accumulator
- * and wrote onto `Object.prototype` for the life of the tab — and
- * `constructor.prototype.x` threw a `TypeError` that surfaced as an unreadable
- * file. Such a column is refused, not sanitised, the way `setIn` settled it
- * (`docs/bug-classes.md` class 22).
- *
- * @param flatObj
- */
-export function unflattenObject(flatObj: { [key: string]: any }) {
-    return Object.keys(flatObj).reduce((nestedObj, key) => {
-        // The string form, so `toPath` rewrites `__proto__[0]` to a `__proto__`
-        // segment too — the bracket branch below writes through the same setter.
-        if (pathTraversesPrototype(key)) {
-            console.warn(`Skipping column "${key}": a header may not reach the prototype chain`);
-            return nestedObj;
-        }
-        let currentObj = nestedObj;
-        const keyParts = key.split(".");
-        keyParts.forEach((keyPart, i) => {
-
-            if (/^[\w]+\[\d+\]$/.test(keyPart)) {
-                const mainPropertyName = keyPart.slice(0, keyPart.indexOf("["));
-                const index = parseInt(keyPart.slice(keyPart.indexOf("[") + 1, keyPart.indexOf("]")));
-
-                if (!currentObj[mainPropertyName]) {
-                    currentObj[mainPropertyName] = []
-                }
-
-                if (i !== keyParts.length - 1) {
-                    currentObj[mainPropertyName][index] = currentObj[mainPropertyName][index] || {};
-                    currentObj = currentObj[mainPropertyName][index];
-                } else {
-                    currentObj[mainPropertyName][index] = flatObj[key];
-                }
-            } else if (i !== keyParts.length - 1) {
-                currentObj[keyPart] = currentObj[keyPart] || {};
-                currentObj = currentObj[keyPart];
-            } else {
-                currentObj[keyPart] = flatObj[key];
-            }
-
-        });
-        return nestedObj;
-    }, {} as { [key: string]: any });
-}
-
-export function mapJsonParse(obj: Record<string, any>) {
-    return Object.keys(obj).reduce((acc: Record<string, any>, key) => {
-        // Same header row, same setter: `acc["__proto__"] = value` replaces the
-        // accumulator's prototype instead of adding a column.
-        if (isPrototypePollutingKey(key)) {
-            console.warn(`Skipping column "${key}": a header may not reach the prototype chain`);
-            return acc;
-        }
-        try {
-            acc[key] = JSON.parse(obj[key]);
-        } catch (e) {
-            acc[key] = obj[key];
-        }
-        return acc;
-    }, {});
-}