@kepler.gl/duckdb 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/esm/processors/data-processor.js

@@ -0,0 +1,342 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import normalize from '@mapbox/geojson-normalize';
+import { getSampleForTypeAnalyze, getFieldsFromData, generateHashId, notNullorUndefined } from '@kepler.gl/common-utils';
+import { ALL_FIELD_TYPES, GUIDES_FILE_FORMAT_DOC } from '@kepler.gl/constants';
+import { processKeplerglJSON } from '@kepler.gl/processors';
+import { getApplicationConfig } from '@kepler.gl/utils';
+export var CSV_NULLS = /^(null|NULL|Null|NaN|\/N||)$/;
+var COLUMN_TYPES = /*#__PURE__*/function (COLUMN_TYPES) {
+  COLUMN_TYPES["GEOMETRY"] = "GEOMETRY";
+  COLUMN_TYPES["BOOLEAN"] = "BOOLEAN";
+  COLUMN_TYPES["INTEGER"] = "INTEGER";
+  COLUMN_TYPES["FLOAT"] = "FLOAT";
+  COLUMN_TYPES["TIME"] = "TIME";
+  COLUMN_TYPES["DATE"] = "DATE";
+  COLUMN_TYPES["TIMESTAMP"] = "TIMESTAMP";
+  COLUMN_TYPES["VARCHAR"] = "VARCHAR";
+  return COLUMN_TYPES;
+}(COLUMN_TYPES || {}); // https://duckdb.org/docs/data/csv/auto_detection.html#type-detection
+export var COLUMN_TYPES_PRIORITIES = ['GEOMETRY', 'BOOLEAN', 'INTEGER', 'FLOAT', 'TIME', 'DATE', 'TIMESTAMP', 'VARCHAR'];
+export function columnTypeToFieldType(columnType) {
+  switch (columnType) {
+    case COLUMN_TYPES.BOOLEAN:
+      return ALL_FIELD_TYPES["boolean"];
+    case COLUMN_TYPES.DATE:
+      return ALL_FIELD_TYPES.date;
+    case COLUMN_TYPES.INTEGER:
+      return ALL_FIELD_TYPES.integer;
+    case COLUMN_TYPES.FLOAT:
+      return ALL_FIELD_TYPES.real;
+    case COLUMN_TYPES.VARCHAR:
+      return ALL_FIELD_TYPES.string;
+    case COLUMN_TYPES.TIMESTAMP:
+      return ALL_FIELD_TYPES.timestamp;
+    case COLUMN_TYPES.GEOMETRY:
+      return ALL_FIELD_TYPES.geojson;
+    default:
+      // is there any other type we didn't cover?
+      console.warn("Unsupported DuckDB Column type: ".concat(columnType));
+      return null;
+  }
+}
+export function fieldTypeToColumnType(fieldType) {
+  switch (fieldType) {
+    case ALL_FIELD_TYPES["boolean"]:
+      return COLUMN_TYPES.BOOLEAN;
+    case ALL_FIELD_TYPES.date:
+      return COLUMN_TYPES.DATE;
+    case ALL_FIELD_TYPES.integer:
+      return COLUMN_TYPES.INTEGER;
+    case ALL_FIELD_TYPES.real:
+      return COLUMN_TYPES.FLOAT;
+    case ALL_FIELD_TYPES.string:
+      return COLUMN_TYPES.VARCHAR;
+    case ALL_FIELD_TYPES.timestamp:
+      return COLUMN_TYPES.TIMESTAMP;
+    case ALL_FIELD_TYPES.geojson:
+      return COLUMN_TYPES.GEOMETRY;
+    default:
+      // is there any other type we didn't cover?
+      console.warn("Unsupported Field type for DuckDb: ".concat(fieldType));
+      return null;
+  }
+}
+
+/*
+ * Process uploaded exported Keplergl json map.
+ * We need to populate field with proper DuckDb compatible type.
+ */
+// TODO: merge with logic from processCsvRowObject. Different formats: [[]] vs [{}]
+export function processKeplerglJSONforDuckDb(_x) {
+  return _processKeplerglJSONforDuckDb.apply(this, arguments);
+}
+
+/*
+ * Process uploaded csv returned by loaders.gl as row object and string value
+ */
+function _processKeplerglJSONforDuckDb() {
+  _processKeplerglJSONforDuckDb = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(keplerJson) {
+    var res, datasets, _iterator, _step, _loop2;
+    return _regeneratorRuntime.wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          res = processKeplerglJSON(keplerJson);
+          datasets = (res === null || res === void 0 ? void 0 : res.datasets) || [];
+          _iterator = _createForOfIteratorHelper(datasets);
+          _context2.prev = 3;
+          _loop2 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop2() {
+            var dataset, rowsAll, fieldsAll, header, sample, schema, fieldsUpd;
+            return _regeneratorRuntime.wrap(function _loop2$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  dataset = _step.value;
+                  rowsAll = dataset.data.rows;
+                  fieldsAll = dataset.data.fields;
+                  header = fieldsAll.map(function (f) {
+                    return f.name;
+                  });
+                  sample = getSampleForTypeAnalyze({
+                    fields: header,
+                    rows: rowsAll
+                  });
+                  if (!(sample.length > 0)) {
+                    _context.next = 11;
+                    break;
+                  }
+                  _context.next = 8;
+                  return sniffCsvSchema(sample);
+                case 8:
+                  _context.t0 = _context.sent;
+                  _context.next = 12;
+                  break;
+                case 11:
+                  _context.t0 = fieldsAll.reduce(function (acc, field) {
+                    acc[field.name] = fieldTypeToColumnType(field.type);
+                    return acc;
+                  }, {});
+                case 12:
+                  schema = _context.t0;
+                  fieldsUpd = consolidateFieldTypes(dataset.data.fields, schema);
+                  dataset.data.fields = fieldsAll.map(function (f, i) {
+                    return _objectSpread(_objectSpread({}, fieldsUpd[i]), f);
+                  });
+                case 15:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop2);
+          });
+          _iterator.s();
+        case 6:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 10;
+            break;
+          }
+          return _context2.delegateYield(_loop2(), "t0", 8);
+        case 8:
+          _context2.next = 6;
+          break;
+        case 10:
+          _context2.next = 15;
+          break;
+        case 12:
+          _context2.prev = 12;
+          _context2.t1 = _context2["catch"](3);
+          _iterator.e(_context2.t1);
+        case 15:
+          _context2.prev = 15;
+          _iterator.f();
+          return _context2.finish(15);
+        case 18:
+          return _context2.abrupt("return", res);
+        case 19:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee, null, [[3, 12, 15, 18]]);
+  }));
+  return _processKeplerglJSONforDuckDb.apply(this, arguments);
+}
+export function processCsvRowObject(_x2) {
+  return _processCsvRowObject.apply(this, arguments);
+}
+function _processCsvRowObject() {
+  _processCsvRowObject = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(rawData) {
+    var header, sample, schema, fieldsWAnalyzerType, fields;
+    return _regeneratorRuntime.wrap(function _callee2$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!(!Array.isArray(rawData) || !rawData.length)) {
+            _context3.next = 2;
+            break;
+          }
+          return _context3.abrupt("return", {
+            fields: [],
+            rows: []
+          });
+        case 2:
+          header = Object.keys(rawData[0]); // [lat, lng, value]
+          // row object can still contain values like `Null` or `N/A`
+          cleanUpFalsyCsvValue(rawData);
+          sample = getSampleForTypeAnalyze({
+            fields: header,
+            rows: rawData
+          }); // add sample data to duckdb and get schema
+          _context3.next = 7;
+          return sniffCsvSchema(sample);
+        case 7:
+          schema = _context3.sent;
+          fieldsWAnalyzerType = getFieldsFromData(sample, header);
+          fields = consolidateFieldTypes(fieldsWAnalyzerType, schema);
+          return _context3.abrupt("return", {
+            rows: rawData,
+            fields: fields
+          });
+        case 11:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee2);
+  }));
+  return _processCsvRowObject.apply(this, arguments);
+}
+function cleanUpFalsyCsvValue(rows) {
+  var re = new RegExp(CSV_NULLS, 'g');
+  var _loop = function _loop(i) {
+    Object.keys(rows[i]).forEach(function (key) {
+      // here we parse empty data as null
+      if (typeof rows[i][key] === 'string' && rows[i][key].match(re)) {
+        rows[i][key] = null;
+      }
+    });
+  };
+  for (var i = 0; i < rows.length; i++) {
+    _loop(i);
+  }
+}
+
+// align type analyzer types with DuckDB csv auto detected column types
+export function consolidateFieldTypes(fields, schema) {
+  return fields.map(function (field) {
+    var columnName = field.name;
+    var detectedColumnType = schema[columnName];
+
+    // TODO columnTypeToFieldType tranforms detected timestamps to string,
+    // completely breaking time filter logic.
+    // const fieldType = columnTypeToFieldType(detectedColumnType) || field.type;
+
+    return _objectSpread(_objectSpread({}, field), {}, {
+      // type: fieldType,
+      duckDBColumnType: detectedColumnType
+    });
+  });
+}
+function toCSVRow(row) {
+  return "".concat(row.map(function (r) {
+    var rToStr = notNullorUndefined(r) ? String(r).replace(/"/g, '\\"') : '';
+    return rToStr.includes(',') ? "\"".concat(rToStr, "\"") : rToStr;
+  }).join(','), "\n");
+}
+
+// Use DucckDB to detect csv column schema
+function sniffCsvSchema(_x3) {
+  return _sniffCsvSchema.apply(this, arguments);
+}
+function _sniffCsvSchema() {
+  _sniffCsvSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(sample) {
+    var headerRow, csvContent, db, c, fileName, result, schemaResult, columns, schema, i;
+    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          if (!(!Array.isArray(sample) || sample.length < 0)) {
+            _context4.next = 2;
+            break;
+          }
+          return _context4.abrupt("return");
+        case 2:
+          headerRow = toCSVRow(Object.keys(sample[0]));
+          csvContent = sample.reduce(function (accu, row) {
+            return "".concat(accu).concat(toCSVRow(Object.values(row)));
+          }, headerRow);
+          db = getApplicationConfig().database;
+          if (db) {
+            _context4.next = 8;
+            break;
+          }
+          console.error('The database is not configured properly.');
+          return _context4.abrupt("return");
+        case 8:
+          _context4.next = 10;
+          return db.connect();
+        case 10:
+          c = _context4.sent;
+          fileName = generateHashId();
+          _context4.next = 14;
+          return db.registerFileText("".concat(fileName, "-").concat(generateHashId, ".csv"), csvContent);
+        case 14:
+          _context4.next = 16;
+          return c.query("\n        FROM sniff_csv('".concat(fileName, "-").concat(generateHashId, ".csv', \n        sample_size = 500,\n        auto_type_candidates = ['FLOAT', 'INTEGER', 'TIMESTAMP', 'DATE', 'TIME', 'VARCHAR', 'BOOLEAN']);\n    "));
+        case 16:
+          result = _context4.sent;
+          schemaResult = result.toArray().map(function (row) {
+            return row.toJSON();
+          });
+          columns = schemaResult[0].Columns;
+          schema = {};
+          for (i = 0; i < columns.length; i++) {
+            schema[columns.get(i).name] = columns.get(i).type;
+          }
+          return _context4.abrupt("return", schema);
+        case 22:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee3);
+  }));
+  return _sniffCsvSchema.apply(this, arguments);
+}
+export function processGeojson(rawData) {
+  var normalizedGeojson = normalize(rawData);
+  if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {
+    var error = new Error("Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](".concat(GUIDES_FILE_FORMAT_DOC, ")"));
+    throw error;
+  }
+
+  // @ts-expect-error Don't pass empty fields, as duck db outputs an empty dataset
+  return {
+    rows: normalizedGeojson
+    // TODO get fields to preserve field names?
+    // fields: []
+  };
+}
+
+/**
+ * A utility function to extend existing fields with native DuckDB column type.
+ * @param fields Array of fields to extend.
+ * @param typeOverrides An optional mapping of DuckDB column types to override.
+ * @returns An array of fields with the DuckDB column type extended.
+ */
+export function extendFieldsWithDuckDBColumnType(fields, typeOverrides) {
+  var schema = fields.reduce(function (acc, field) {
+    acc[field.name] = fieldTypeToColumnType(field.type);
+    return acc;
+  }, {});
+  var updatedFields = consolidateFieldTypes(fields, schema);
+  updatedFields.forEach(function (field) {
+    if (typeOverrides[field.duckDBColumnType]) {
+      field.duckDBColumnType = typeOverrides[field.duckDBColumnType];
+    }
+  });
+  return updatedFields;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["normalize","getSampleForTypeAnalyze","getFieldsFromData","generateHashId","notNullorUndefined","ALL_FIELD_TYPES","GUIDES_FILE_FORMAT_DOC","processKeplerglJSON","getApplicationConfig","CSV_NULLS","COLUMN_TYPES","COLUMN_TYPES_PRIORITIES","columnTypeToFieldType","columnType","BOOLEAN","DATE","date","INTEGER","integer","FLOAT","real","VARCHAR","string","TIMESTAMP","timestamp","GEOMETRY","geojson","console","warn","concat","fieldTypeToColumnType","fieldType","processKeplerglJSONforDuckDb","_x","_processKeplerglJSONforDuckDb","apply","arguments","_asyncToGenerator","_regeneratorRuntime","mark","_callee","keplerJson","res","datasets","_iterator","_step","_loop2","wrap","_callee$","_context2","prev","next","_createForOfIteratorHelper","dataset","rowsAll","fieldsAll","header","sample","schema","fieldsUpd","_loop2$","_context","value","data","rows","fields","map","f","name","length","sniffCsvSchema","t0","sent","reduce","acc","field","type","consolidateFieldTypes","i","_objectSpread","stop","s","n","done","delegateYield","t1","e","finish","abrupt","processCsvRowObject","_x2","_processCsvRowObject","_callee2","rawData","fieldsWAnalyzerType","_callee2$","_context3","Array","isArray","Object","keys","cleanUpFalsyCsvValue","re","RegExp","_loop","forEach","key","match","columnName","detectedColumnType","duckDBColumnType","toCSVRow","row","r","rToStr","String","replace","includes","join","_x3","_sniffCsvSchema","_callee3","headerRow","csvContent","db","c","fileName","result","schemaResult","columns","_callee3$","_context4","accu","values","database","error","connect","registerFileText","query","toArray","toJSON","Columns","get","processGeojson","normalizedGeojson","features","Error","extendFieldsWithDuckDBColumnType","typeOverrides","updatedFields"],"sources":["../../../src/processors/data-processor.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport normalize from '@mapbox/geojson-normalize';\n\nimport {\n  getSampleForTypeAnalyze,\n  getFieldsFromData,\n  generateHashId,\n  notNullorUndefined\n} from '@kepler.gl/common-utils';\nimport {ProtoDatasetField} from '@kepler.gl/types';\nimport {ALL_FIELD_TYPES, GUIDES_FILE_FORMAT_DOC} from '@kepler.gl/constants';\nimport {processKeplerglJSON} from '@kepler.gl/processors';\nimport {getApplicationConfig} from '@kepler.gl/utils';\n\nexport const CSV_NULLS = /^(null|NULL|Null|NaN|\\/N||)$/;\n\ntype RowsAsArray = any[][];\ntype RowsAsObject = Record<string, unknown>[];\ntype RowData = RowsAsArray | RowsAsObject;\n\nexport type ProcessorResult = {\n  cols?: arrow.Vector[];\n  rows: RowData;\n  fields: ProtoDatasetField[];\n};\n\nenum COLUMN_TYPES {\n  GEOMETRY = 'GEOMETRY',\n  BOOLEAN = 'BOOLEAN',\n  INTEGER = 'INTEGER',\n  FLOAT = 'FLOAT',\n  TIME = 'TIME',\n  DATE = 'DATE',\n  TIMESTAMP = 'TIMESTAMP',\n  VARCHAR = 'VARCHAR'\n}\n// https://duckdb.org/docs/data/csv/auto_detection.html#type-detection\nexport const COLUMN_TYPES_PRIORITIES = [\n  'GEOMETRY',\n  'BOOLEAN',\n  'INTEGER',\n  'FLOAT',\n  'TIME',\n  'DATE',\n  'TIMESTAMP',\n  'VARCHAR'\n];\n\nexport function columnTypeToFieldType(columnType: string): string | null {\n  switch (columnType) {\n    case COLUMN_TYPES.BOOLEAN:\n      return ALL_FIELD_TYPES.boolean;\n    case COLUMN_TYPES.DATE:\n      return ALL_FIELD_TYPES.date;\n    case COLUMN_TYPES.INTEGER:\n      return ALL_FIELD_TYPES.integer;\n    case COLUMN_TYPES.FLOAT:\n      return ALL_FIELD_TYPES.real;\n    case COLUMN_TYPES.VARCHAR:\n      return ALL_FIELD_TYPES.string;\n    case COLUMN_TYPES.TIMESTAMP:\n      return ALL_FIELD_TYPES.timestamp;\n    case COLUMN_TYPES.GEOMETRY:\n      return ALL_FIELD_TYPES.geojson;\n    default:\n      // is there any other type we didn't cover?\n      console.warn(`Unsupported DuckDB Column type: ${columnType}`);\n      return null;\n  }\n}\n\nexport function fieldTypeToColumnType(fieldType: string): string | null {\n  switch (fieldType) {\n    case ALL_FIELD_TYPES.boolean:\n      return COLUMN_TYPES.BOOLEAN;\n    case ALL_FIELD_TYPES.date:\n      return COLUMN_TYPES.DATE;\n    case ALL_FIELD_TYPES.integer:\n      return COLUMN_TYPES.INTEGER;\n    case ALL_FIELD_TYPES.real:\n      return COLUMN_TYPES.FLOAT;\n    case ALL_FIELD_TYPES.string:\n      return COLUMN_TYPES.VARCHAR;\n    case ALL_FIELD_TYPES.timestamp:\n      return COLUMN_TYPES.TIMESTAMP;\n    case ALL_FIELD_TYPES.geojson:\n      return COLUMN_TYPES.GEOMETRY;\n    default:\n      // is there any other type we didn't cover?\n      console.warn(`Unsupported Field type for DuckDb: ${fieldType}`);\n      return null;\n  }\n}\n\n/*\n * Process uploaded exported Keplergl json map.\n * We need to populate field with proper DuckDb compatible type.\n */\n// TODO: merge with logic from processCsvRowObject. Different formats: [[]] vs [{}]\nexport async function processKeplerglJSONforDuckDb(\n  keplerJson\n): Promise<ReturnType<typeof processKeplerglJSON>> {\n  const res = processKeplerglJSON(keplerJson);\n\n  const datasets = res?.datasets || [];\n  for (const dataset of datasets) {\n    const rowsAll = dataset.data.rows;\n    const fieldsAll = dataset.data.fields;\n\n    const header = fieldsAll.map(f => f.name);\n    const sample = getSampleForTypeAnalyze({fields: header, rows: rowsAll});\n\n    const schema =\n      sample.length > 0\n        ? await sniffCsvSchema(sample)\n        : fieldsAll.reduce((acc, field) => {\n            acc[field.name] = fieldTypeToColumnType(field.type);\n            return acc;\n          }, {});\n    const fieldsUpd = consolidateFieldTypes(dataset.data.fields, schema);\n\n    dataset.data.fields = fieldsAll.map((f, i) => {\n      return {...fieldsUpd[i], ...f};\n    });\n  }\n\n  return res;\n}\n\n/*\n * Process uploaded csv returned by loaders.gl as row object and string value\n */\nexport async function processCsvRowObject(\n  rawData: Record<string, string | null>[]\n): Promise<ProcessorResult> {\n  if (!Array.isArray(rawData) || !rawData.length) {\n    return {\n      fields: [],\n      rows: []\n    };\n  }\n\n  const header = Object.keys(rawData[0]); // [lat, lng, value]\n\n  // row object can still contain values like `Null` or `N/A`\n  cleanUpFalsyCsvValue(rawData);\n  const sample = getSampleForTypeAnalyze({fields: header, rows: rawData});\n  // add sample data to duckdb and get schema\n  const schema = await sniffCsvSchema(sample);\n\n  const fieldsWAnalyzerType = getFieldsFromData(sample, header);\n\n  const fields = consolidateFieldTypes(fieldsWAnalyzerType, schema);\n\n  return {rows: rawData, fields};\n}\n\nfunction cleanUpFalsyCsvValue(rows: RowData): void {\n  const re = new RegExp(CSV_NULLS, 'g');\n  for (let i = 0; i < rows.length; i++) {\n    Object.keys(rows[i]).forEach(key => {\n      // here we parse empty data as null\n      if (typeof rows[i][key] === 'string' && (rows[i][key] as string).match(re)) {\n        rows[i][key] = null;\n      }\n    });\n  }\n}\n\n// align type analyzer types with DuckDB csv auto detected column types\nexport function consolidateFieldTypes(fields, schema) {\n  return fields.map(field => {\n    const columnName = field.name;\n\n    const detectedColumnType = schema[columnName];\n\n    // TODO columnTypeToFieldType tranforms detected timestamps to string,\n    // completely breaking time filter logic.\n    // const fieldType = columnTypeToFieldType(detectedColumnType) || field.type;\n\n    return {\n      ...field,\n      // type: fieldType,\n      duckDBColumnType: detectedColumnType\n    };\n  });\n}\n\nfunction toCSVRow(row: unknown[]): string {\n  return `${row\n    .map(r => {\n      const rToStr = notNullorUndefined(r) ? String(r).replace(/\"/g, '\\\\\"') : '';\n      return rToStr.includes(',') ? `\"${rToStr}\"` : rToStr;\n    })\n    .join(',')}\\n`;\n}\n\n// Use DucckDB to detect csv column schema\nasync function sniffCsvSchema(sample: RowData) {\n  if (!Array.isArray(sample) || sample.length < 0) {\n    return;\n  }\n  const headerRow = toCSVRow(Object.keys(sample[0]));\n\n  const csvContent = (sample as (any[] | Record<string, unknown>)[]).reduce(\n    (accu: string, row) => `${accu}${toCSVRow(Object.values(row))}`,\n    headerRow\n  );\n\n  const db = getApplicationConfig().database;\n  if (!db) {\n    console.error('The database is not configured properly.');\n    return;\n  }\n  const c = await db.connect();\n\n  const fileName = generateHashId();\n  await db.registerFileText(`${fileName}-${generateHashId}.csv`, csvContent);\n\n  // https://duckdb.org/docs/data/csv/auto_detection.html\n  const result = await c.query(`\n        FROM sniff_csv('${fileName}-${generateHashId}.csv', \n        sample_size = 500,\n        auto_type_candidates = ['FLOAT', 'INTEGER', 'TIMESTAMP', 'DATE', 'TIME', 'VARCHAR', 'BOOLEAN']);\n    `);\n\n  const schemaResult = result.toArray().map(row => row.toJSON());\n\n  const columns = schemaResult[0].Columns;\n  const schema = {};\n  for (let i = 0; i < columns.length; i++) {\n    schema[columns.get(i).name] = columns.get(i).type;\n  }\n\n  return schema;\n}\n\nexport function processGeojson(rawData: unknown): ProcessorResult {\n  const normalizedGeojson = normalize(rawData);\n\n  if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {\n    const error = new Error(\n      `Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](${GUIDES_FILE_FORMAT_DOC})`\n    );\n    throw error;\n  }\n\n  // @ts-expect-error Don't pass empty fields, as duck db outputs an empty dataset\n  return {\n    rows: normalizedGeojson\n    // TODO get fields to preserve field names?\n    // fields: []\n  };\n}\n\n/**\n * A utility function to extend existing fields with native DuckDB column type.\n * @param fields Array of fields to extend.\n * @param typeOverrides An optional mapping of DuckDB column types to override.\n * @returns An array of fields with the DuckDB column type extended.\n */\nexport function extendFieldsWithDuckDBColumnType(\n  fields: ProtoDatasetField[],\n  typeOverrides: Record<string, string>\n): Promise<ProtoDatasetField[]> {\n  const schema = fields.reduce((acc, field) => {\n    acc[field.name] = fieldTypeToColumnType(field.type);\n    return acc;\n  }, {});\n\n  const updatedFields = consolidateFieldTypes(fields, schema);\n  updatedFields.forEach(field => {\n    if (typeOverrides[field.duckDBColumnType]) {\n      field.duckDBColumnType = typeOverrides[field.duckDBColumnType];\n    }\n  });\n  return updatedFields;\n}\n"],"mappings":"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","ignoreList":[]}