dobo-extra 2.4.0 → 2.5.1

package/index.js

@@ -1,84 +1,257 @@
-import exportTo from './lib/export-to.js'
-import importFrom from './lib/import-from.js'
+import path from 'path'
+import { json, ndjson, csv, xlsx } from './lib/helper.js'
+import { createGunzip, createGzip } from 'zlib'
+import scramjet from 'scramjet'
+import config from './lib/config.js'
+
+const { DataStream } = scramjet
+const exts = ['.json', '.jsonl', '.ndjson', '.csv', '.xlsx', '.tsv']
 
 /**
- * Plugin factory
+ * Plugin factory.
+ *
+ * **Never** call this function directly!!! It's only-meant to be called by the {@link https://ardhi.github.io/bajo|Bajo framework} during plugin initialization.
  *
  * @param {string} pkgName - NPM package name
- * @returns {class}
+ * @returns {DoboExtra}
  */
 async function factory (pkgName) {
   const me = this
 
   /**
-   * DoboExtra class
+   * DoboExtra class definition
    *
-   * @class
+   * This class provides more functionality to the Dobo plugin including:
+   * - new additional `ndjson` format for Bajo's configHandlers
+   * - data import/export from/to file system in various formats (JSON, NDJSON, CSV, TSV, XLSX)
+   *
+   *  @class
    */
   class DoboExtra extends this.app.baseClass.Base {
     constructor () {
+      /**
+       * Constructor
+       */
       super(pkgName, me.app)
-      this.config = {
-        export: {
-          maxBatch: 1000,
-          stringify: {
-            open: '[\n',
-            sep: ',\n',
-            close: '\n]\n'
-          }
-        },
-        import: {
-          maxBatch: 1000
-        },
-        archive: {
-          tasks: [],
-          checkInterval: false,
-          runEarly: true
-        }
-      }
 
-      this.selfBind(['exportTo', 'importFrom'])
+      /**
+       * Configuration object
+       * @type {TConfig}
+       */
+      this.config = config
     }
 
-    init = async () => {
-      const { buildCollections } = this.app.bajo
-      const types = ['datetime', 'date', 'timestamp']
+    /**
+     * Import data from a file into a Dobo model
+     *
+     * @async
+     * @method
+     * @param {string} source - Source file path (absolute or relative to plugin data dir)
+     * @param {string|boolean} dest - Destination model name or `false`. If `false`, the data will be returned instead of being imported into a model.
+     * @param {object} options - Import options
+     * @param {boolean} [options.trashOld=true] - Whether to clear the destination model before importing
+     * @param {number} [options.batch=100] - Number of records to import in a single batch.
+     * @param {function} [options.progressFn] - Callback function to report progress
+     * @param {function} [options.converterFn] - Callback function to convert each record before importing
+     * @param {boolean} [options.useHeader=true] - Whether to use the first row as header (for CSV/TSV/XLSX)
+     * @param {string} [options.fileType] - File type (json, ndjson, csv, tsv, xlsx)
+     * @returns {Promise<object|array>} - Imported data or summary report including file path and record count affected
+     */
+    importFrom = async (source, dest, options = {}) => {
+      let {
+        trashOld = true, batch = 100, progressFn, converterFn, useHeader = true,
+        fileType, createOpts = {}, parserOpts = {}
+      } = options
+      const { merge } = this.app.lib._
+      const { fs } = this.app.lib
+      const { getModel } = this.app.dobo
 
-      async function handler ({ item }) {
-        const { join } = this.app.bajo
-        const { getSchema } = this.app.dobo
-        const { has } = this.app.lib._
-        for (const f of ['source', 'destination']) {
-          if (!has(item, f)) throw this.error('taskMustHaveModel%s', f)
-          const key = `${f}Field`
-          item[key] = item[key] ?? 'createdAt'
-          const schema = getSchema(item[f])
-          const prop = schema.properties.find(p => p.name === item[key])
-          if (!prop) throw this.error('unknownField%s%s', item[key], item[f])
-          if (!types.includes(prop.type)) throw this.error('isNotSupported%s%s%s%s', item[key], item[f], prop.type, join(types))
-        }
-        if (item.source === item.destination) throw this.error('sourceDestMustBeDifferent')
-        item.maxAge = item.maxAge ?? 1 // in days, less then 1 is ignored
+      let dmodel
+      if (dest !== false) dmodel = getModel(dest) // make sure dest model is valid
+      let file
+      if (path.isAbsolute(source)) file = source
+      else {
+        file = `${this.app.getPluginDataDir(this.ns)}/import/${source}`
+        fs.ensureDirSync(path.dirname(file))
       }
+      if (!fs.existsSync(file)) throw this.error('sourceFileNotExists%s', file)
+      let ext = fileType ? `.${fileType}` : path.extname(file)
+      let decompress = false
+      if (ext === '.gz') {
+        ext = path.extname(path.basename(file, '.gz'))
+        decompress = true
+      }
+      if (!exts.includes(ext)) throw this.error('unsupportedFormat%s', ext.slice(1))
+      if (trashOld && dest !== false) await dmodel.clearRecord()
+      const reader = fs.createReadStream(file)
+      batch = parseInt(batch) || 100
+      if (batch > this.config.import.maxBatch) batch = this.config.import.maxBatch
+      if (batch < 0) batch = 1
+      let count = 0
+      const pipes = [reader]
+      if (decompress) pipes.push(createGunzip())
+      if (ext === '.json') pipes.push(json.parse(parserOpts))
+      else if (['.ndjson', '.jsonl'].includes(ext)) pipes.push(ndjson.parse(parserOpts))
+      else if (ext === '.csv') pipes.push(csv.parse(merge({}, { headers: useHeader }, parserOpts)))
+      else if (ext === '.tsv') pipes.push(csv.parse(merge({}, { headers: useHeader }, merge({}, parserOpts, { delimiter: '\t' }))))
+      else if (ext === '.xlsx') pipes.push(xlsx.parse(merge({}, { header: useHeader }, parserOpts)))
+
+      const stream = DataStream.pipeline(...pipes)
+      let batchNo = 1
+      const data = []
+      await stream
+        .batch(batch)
+        .map(async items => {
+          if (items.length === 0) return null
+          const batchStart = new Date()
+          for (let item of items) {
+            count++
+            item = converterFn ? await converterFn.call(this, item) : item
+            if (dest !== false) await dmodel.createRecord(item, createOpts)
+            else data.push(item)
+          }
+          if (progressFn) await progressFn.call(this, { batchNo, data: items, batchStart, batchEnd: new Date() })
+          batchNo++
+        })
+        .run()
 
-      this.archivers = await buildCollections({ ns: this.ns, handler, container: 'archive.tasks', dupChecks: ['source'], useDefaultName: false })
+      return dest === false ? data : { file, count }
     }
 
-    start = async () => {
-      if (this.config.archive.checkInterval === false || this.config.archive.checkInterval <= 0) {
-        this.log.warn('autoArchiveDisabled')
-        return
+    /**
+     * Export data from a Dobo model into a file
+     * @async
+     * @method
+     * @param {string} source - Source model name
+     * @param {string} dest - Destination file path (absolute or relative to plugin data dir)
+     * @param {object} options - Export options
+     * @param {object} [options.filter={}] - Filter object to select records to export
+     * @param {boolean} [options.ensureDir] - Whether to create the destination directory if it doesn't exist
+     * @param {boolean} [options.useHeader=true] - Whether to include the header row (for CSV/TSV/XLSX)
+     * @param {number} [options.batch=500] - Number of records to export in a single batch
+     * @param {function} [options.progressFn] - Callback function to report progress
+     * @param {Array<string>} [options.fields] - List of fields to include in the export
+     * @param {object} [options.parserOpts={}] - Options for the parser (e.g., CSV delimiter)
+     * @returns {Promise<object>} - Export summary including file path and record count affected
+     */
+    exportTo = (source, dest, options = {}) => {
+      let {
+        filter = {}, ensureDir, useHeader = true, batch = 500,
+        progressFn, fields, parserOpts = {}
+      } = options
+      const { importPkg } = this.app.bajo
+      const { fs } = this.app.lib
+      const { merge, omit } = this.app.lib._
+      const { getModel } = this.app.dobo
+
+      const getFile = async () => {
+        const increment = await importPkg('bajo:add-filename-increment')
+        let file
+        if (path.isAbsolute(dest)) file = dest
+        else {
+          file = `${this.app.getPluginDataDir(this.ns)}/export/${dest}`
+          fs.ensureDirSync(path.dirname(file))
+        }
+        file = increment(file, { fs: true, platform: 'win32' })
+        const dir = path.dirname(file)
+        if (!fs.existsSync(dir)) {
+          if (ensureDir) fs.ensureDirSync(dir)
+          else throw this.error('dirNotExists%s', dir)
+        }
+        let compress = false
+        let ext = path.extname(file)
+        if (ext === '.gz') {
+          compress = true
+          ext = path.extname(file.slice(0, -3))
+          // file = file.slice(0, file.length - 3)
+        }
+        if (!exts.includes(ext)) throw this.error('unsupportedFormat%s', ext.slice(1))
+        return { file, ext, compress }
       }
-      if (this.config.archive.runEarly) await this.archive()
-      this.archiveIntv = setInterval(() => {
-        this.archive().then().catch(err => {
-          this.log.error('archiveError%s', err.message)
-        })
-      }, this.config.archive.checkInterval * 60 * 1000)
-    }
 
-    exportTo = exportTo
-    importFrom = importFrom
+      const getData = async (options = {}) => {
+        const { source, filter, count, stream, progressFn, fields } = options
+        let cnt = count ?? 0
+        const { find } = this.app.lib._
+        const { getModel } = this.app.dobo
+        const { maxLimit, hardCap } = this.app.dobo.config.default.filter
+        filter.limit = maxLimit
+        let sort
+        const model = getModel(source)
+        const idField = find(model.properties, { name: 'id' }).name
+        for (const name of ['createdAt', 'updatedAt', 'ts', 'dt']) {
+          const field = find(model.properties, { name })
+          if (field) {
+            sort = field.name
+            break
+          }
+        }
+        filter.sort = `${sort ?? idField}:1`
+        for (;;) {
+          const batchStart = new Date()
+          const { data: rows, page } = await model.findRecord(filter, { dataOnly: false, fields, fmt: true, refs: '*', noCache: true })
+          const data = rows.map(item => omit(item, ['_immutable', '_fmt', '_ref']))
+          if (data.length === 0) break
+          if (cnt + data.length > hardCap) {
+            const sliced = data.slice(0, hardCap - cnt)
+            await stream.pull(sliced)
+            cnt += sliced.length
+            if (progressFn) await progressFn.call(this, { batchNo: page, data: sliced, batchStart, batchEnd: new Date() })
+            break
+          }
+          cnt += data.length
+          await stream.pull(data)
+          if (progressFn) await progressFn.call(this, { batchNo: page, data, batchStart, batchEnd: new Date() })
+          filter.page++
+        }
+        await stream.end()
+        return cnt
+      }
+
+      filter.page = 1
+      batch = parseInt(batch) ?? 500
+      if (batch > this.config.export.maxBatch) batch = this.config.export.maxBatch
+      if (batch < 0) batch = 1
+      filter.limit = batch
+
+      return new Promise((resolve, reject) => {
+        let count = 0
+        let file
+        let ext
+        let stream
+        let compress
+        let writer
+        getModel(source)
+        getFile()
+          .then(res => {
+            file = res.file
+            ext = res.ext
+            compress = res.compress
+            writer = fs.createWriteStream(file)
+            writer.on('error', err => {
+              reject(err)
+            })
+            writer.on('finish', () => {
+              resolve({ file, count })
+            })
+            stream = new DataStream()
+            stream = stream.flatMap(items => (items))
+            const pipes = []
+            if (ext === '.json') pipes.push(json.stringify(parserOpts))
+            else if (['.ndjson', '.jsonl'].includes(ext)) pipes.push(ndjson.stringify(parserOpts))
+            else if (ext === '.csv') pipes.push(csv.stringify(merge({}, { headers: useHeader }, parserOpts)))
+            else if (ext === '.tsv') pipes.push(csv.stringify(merge({}, { headers: useHeader }, merge({}, parserOpts, { delimiter: '\t' }))))
+            else if (ext === '.xlsx') pipes.push(xlsx.stringify(merge({}, { header: useHeader }, parserOpts)))
+            if (compress) pipes.push(createGzip())
+            DataStream.pipeline(stream, ...pipes).pipe(writer)
+            return getData({ source, filter, count, stream, fields, progressFn })
+          })
+          .then(cnt => {
+            count = cnt
+          })
+          .catch(reject)
+      })
+    }
   }
 
   return DoboExtra

package/lib/config.js

@@ -0,0 +1,28 @@
+/**
+ * @typedef TConfig
+ * @memberof DoboExtra
+ * @type {object}
+ * @property {object} export - Export configuration
+ * @property {number} export.maxBatch - Maximum number of records to export in a single batch
+ * @property {object} export.stringify - Stringify options for exported data
+ * @property {string} export.stringify.open - Opening string for exported data
+ * @property {string} export.stringify.sep - Separator string for exported data
+ * @property {string} export.stringify.close - Closing string for exported data
+ * @property {object} import - Import configuration
+ * @property {number} import.maxBatch - Maximum number of records to import in a single batch
+ */
+const config = {
+  export: {
+    maxBatch: 1000,
+    stringify: {
+      open: '[\n',
+      sep: ',\n',
+      close: '\n]\n'
+    }
+  },
+  import: {
+    maxBatch: 1000
+  }
+}
+
+export default config

package/lib/helper.js

@@ -0,0 +1,96 @@
+import ndj from 'ndjson'
+import fastCsv from 'fast-csv'
+import xlsxparse from 'xlsx-parse-stream'
+import XLSXWriteStream from '@atomictech/xlsx-write-stream'
+import StreamArray from 'stream-json/streamers/StreamArray.js'
+import Stringer from 'stream-json/Stringer.js'
+import Disassembler from 'stream-json/Disassembler.js'
+import chain from 'stream-chain'
+
+/**
+ * Helper functions for Dobo Extra
+ * @module Helper
+ */
+
+// Borrow the idea from: https://github.com/fanlia/ndjson-csv-xlsx/blob/main/index.js
+
+const XLSXStreamer = XLSXWriteStream.default
+
+/**
+ * NDJSON parser and stringifier.
+ *
+ * To be able to use this helper, do something like this:
+ * ```js
+ * const { importModule } = this.app.bajo
+ * const { ndjson } = await importModule('dobo-extra:/lib/helper.js', { asDefaultImport: false })
+ * console.log(ndjson.parse('{"a":1}\n{"b":2}')) // [{a:1},{b:2}]
+ * console.log(ndjson.stringify([{a:1},{b:2}])) // '{"a":1}\n{"b":2}\n'
+ * ```
+ * @type {object}
+ * @property {function} parse - Parse NDJSON data
+ * @property {function} stringify - Stringify data to NDJSON format
+ */
+export const ndjson = {
+  parse: (...args) => ndj.parse(...args),
+  stringify: (...args) => ndj.stringify(...args)
+}
+
+/**
+ * CSV parser and stringifier.
+ *
+ * To be able to use this helper, do something like this:
+ * ```js
+ * const { importModule } = this.app.bajo
+ * const { csv } = await importModule('dobo-extra:/lib/helper.js', { asDefaultImport: false })
+ * ...
+ * ```
+ * @type {object}
+ * @property {function} parse - Parse CSV data
+ * @property {function} stringify - Stringify data to CSV format
+ */
+export const csv = {
+  parse: (...args) => fastCsv.parse(...args),
+  stringify: (...args) => fastCsv.format(...args)
+}
+
+/**
+ * Excel XLSX parser and stringifier.
+ *
+ * To be able to use this helper, do something like this:
+ * ```js
+ * const { importModule } = this.app.bajo
+ * const { xlsx } = await importModule('dobo-extra:/lib/helper.js', { asDefaultImport: false })
+ * ...
+ * ```
+ * @type {object}
+ * @property {function} parse - Parse XLSX data
+ * @property {function} stringify - Stringify data to XLSX format
+ */
+export const xlsx = {
+  parse: (...args) => xlsxparse(...args),
+  stringify: (...args) => new XLSXStreamer(...args)
+}
+
+/**
+ * JSON parser and stringifier. Use stream to handle large JSON files.
+ *
+ * To be able to use this helper, do something like this:
+ * ```js
+ * const { importModule } = this.app.bajo
+ * const { json } = await importModule('dobo-extra:/lib/helper.js', { asDefaultImport: false })
+ * ...
+ * ```
+ * @type {object}
+ * @property {function} parse - Parse JSON data
+ * @property {function} stringify - Stringify data to JSON format
+ */
+export const json = {
+  parse: (...args) => chain([
+    StreamArray.withParser(...args),
+    data => data.value
+  ]),
+  stringify: (options, ...args) => chain([
+    new Disassembler(),
+    new Stringer({ ...options, makeArray: true })
+  ])
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo-extra",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Bajo DB Extra Tools/Utility",
   "main": "index.js",
   "scripts": {
@@ -20,7 +20,7 @@
   "keywords": [
     "extra",
     "db",
-    "driver",
+    "adapter",
     "bajo",
     "framework",
     "modular"

package/wiki/CHANGES.md

@@ -1,5 +1,14 @@
 # Changes
 
+## 2026-07-25
+
+- [2.5.1] Bug fix in `exportTo()`
+
+## 2026-07-13
+
+- [2.5.0] Reorganize files
+- [2.5.0] Update documentations
+
 ## 2026-06-12
 
 - [2.4.0] Necessary updates to ```bajo@2.18.0``` specs

package/lib/export-to.js

@@ -1,123 +0,0 @@
-import path from 'path'
-import { json, ndjson, csv, xlsx } from './ndjson-csv-xlsx.js'
-import { createGzip } from 'node:zlib'
-import scramjet from 'scramjet'
-import supportedExt from './io-exts.js'
-
-const { DataStream } = scramjet
-
-async function getFile (dest, ensureDir) {
-  const { importPkg } = this.app.bajo
-  const { fs } = this.app.lib
-  const increment = await importPkg('bajo:add-filename-increment')
-  let file
-  if (path.isAbsolute(dest)) file = dest
-  else {
-    file = `${this.app.getPluginDataDir(this.ns)}/export/${dest}`
-    fs.ensureDirSync(path.dirname(file))
-  }
-  file = increment(file, { fs: true })
-  const dir = path.dirname(file)
-  if (!fs.existsSync(dir)) {
-    if (ensureDir) fs.ensureDirSync(dir)
-    else throw this.error('dirNotExists%s', dir)
-  }
-  let compress = false
-  let ext = path.extname(file)
-  if (ext === '.gz') {
-    compress = true
-    ext = path.extname(file.slice(0, -3))
-    // file = file.slice(0, file.length - 3)
-  }
-  if (!supportedExt.includes(ext)) throw this.error('unsupportedFormat%s', ext.slice(1))
-  return { file, ext, compress }
-}
-
-async function getData ({ source, filter, count, stream, progressFn, fields }) {
-  let cnt = count ?? 0
-  const { find } = this.app.lib._
-  const { recordFind, getSchema } = this.app.dobo
-  const { maxLimit, hardCap } = this.app.dobo.config.default.filter
-  filter.limit = maxLimit
-  let sort
-  const schema = getSchema(source)
-  const idField = find(schema.properties, { name: 'id' })
-  for (const name of ['createdAt', 'updatedAt', 'ts', 'dt']) {
-    const field = find(schema.properties, { name })
-    if (field) {
-      sort = field.name
-      break
-    }
-  }
-  filter.sort = `${sort ?? idField}:1`
-  for (;;) {
-    const batchStart = new Date()
-    const { data, page } = await recordFind(source, filter, { dataOnly: false, fields })
-    if (data.length === 0) break
-    if (cnt + data.length > hardCap) {
-      const sliced = data.slice(0, hardCap - cnt)
-      await stream.pull(sliced)
-      cnt += sliced.length
-      if (progressFn) await progressFn.call(this, { batchNo: page, data: sliced, batchStart, batchEnd: new Date() })
-      break
-    }
-    cnt += data.length
-    await stream.pull(data)
-    if (progressFn) await progressFn.call(this, { batchNo: page, data, batchStart, batchEnd: new Date() })
-    filter.page++
-  }
-  await stream.end()
-  return cnt
-}
-
-function exportTo (source, dest, { filter = {}, ensureDir, useHeader = true, batch = 500, progressFn, fields } = {}, opts = {}) {
-  const { fs } = this.app.lib
-  const { merge } = this.app.lib._
-  const { getInfo } = this.app.dobo
-
-  filter.page = 1
-  batch = parseInt(batch) ?? 500
-  if (batch > this.config.export.maxBatch) batch = this.config.export.maxBatch
-  if (batch < 0) batch = 1
-  filter.limit = batch
-
-  return new Promise((resolve, reject) => {
-    let count = 0
-    let file
-    let ext
-    let stream
-    let compress
-    let writer
-    getInfo(source)
-    getFile.call(this, dest, ensureDir)
-      .then(res => {
-        file = res.file
-        ext = res.ext
-        compress = res.compress
-        writer = fs.createWriteStream(file)
-        writer.on('error', err => {
-          reject(err)
-        })
-        writer.on('finish', () => {
-          resolve({ file, count })
-        })
-        stream = new DataStream()
-        stream = stream.flatMap(items => (items))
-        const pipes = []
-        if (ext === '.json') pipes.push(json.stringify(opts))
-        else if (['.ndjson', '.jsonl'].includes(ext)) pipes.push(ndjson.stringify(opts))
-        else if (ext === '.csv') pipes.push(csv.stringify(merge({}, { headers: useHeader }, opts)))
-        else if (ext === '.tsv') pipes.push(csv.stringify(merge({}, { headers: useHeader }, merge({}, opts, { delimiter: '\t' }))))
-        else if (ext === '.xlsx') pipes.push(xlsx.stringify(merge({}, { header: useHeader }, opts)))
-        if (compress) pipes.push(createGzip())
-        DataStream.pipeline(stream, ...pipes).pipe(writer)
-        return getData.call(this, { source, filter, count, stream, fields, progressFn })
-      })
-      .then(cnt => {
-        count = cnt
-      })
-      .catch(reject)
-  })
-}
-
-export default exportTo

package/lib/import-from.js

@@ -1,65 +0,0 @@
-import path from 'path'
-import { json, ndjson, csv, xlsx } from './ndjson-csv-xlsx.js'
-import { createGunzip } from 'zlib'
-import supportedExt from './io-exts.js'
-import scramjet from 'scramjet'
-
-const { DataStream } = scramjet
-
-async function importFrom (source, dest, { trashOld = true, batch = 1, progressFn, converterFn, useHeader = true, fileType, createOpts = {} } = {}, opts = {}) {
-  const { recordCreate } = this.app.dobo
-  const { merge } = this.app.lib._
-  const { fs } = this.app.lib
-
-  if (dest !== false) this.app.dobo.getInfo(dest) // make sure dest model is valid
-  let file
-  if (path.isAbsolute(source)) file = source
-  else {
-    file = `${this.app.getPluginDataDir(this.ns)}/import/${source}`
-    fs.ensureDirSync(path.dirname(file))
-  }
-  if (!fs.existsSync(file)) throw this.error('sourceFileNotExists%s', file)
-  let ext = fileType ? `.${fileType}` : path.extname(file)
-  let decompress = false
-  if (ext === '.gz') {
-    ext = path.extname(path.basename(file, '.gz'))
-    decompress = true
-  }
-  if (!supportedExt.includes(ext)) throw this.error('unsupportedFormat%s', ext.slice(1))
-  if (trashOld && dest !== false) await this.app.dobo.modelClear(dest)
-  const reader = fs.createReadStream(file)
-  batch = parseInt(batch) || 100
-  if (batch > this.config.import.maxBatch) batch = this.config.import.maxBatch
-  if (batch < 0) batch = 1
-  let count = 0
-  const pipes = [reader]
-  if (decompress) pipes.push(createGunzip())
-  if (ext === '.json') pipes.push(json.parse(opts))
-  else if (['.ndjson', '.jsonl'].includes(ext)) pipes.push(ndjson.parse(opts))
-  else if (ext === '.csv') pipes.push(csv.parse(merge({}, { headers: useHeader }, opts)))
-  else if (ext === '.tsv') pipes.push(csv.parse(merge({}, { headers: useHeader }, merge({}, opts, { delimiter: '\t' }))))
-  else if (ext === '.xlsx') pipes.push(xlsx.parse(merge({}, { header: useHeader }, opts)))
-
-  const stream = DataStream.pipeline(...pipes)
-  let batchNo = 1
-  const data = []
-  await stream
-    .batch(batch)
-    .map(async items => {
-      if (items.length === 0) return null
-      const batchStart = new Date()
-      for (let item of items) {
-        count++
-        item = converterFn ? await converterFn.call(this, item) : item
-        if (dest !== false) await recordCreate(dest, item, createOpts)
-        else data.push(item)
-      }
-      if (progressFn) await progressFn.call(this, { batchNo, data: items, batchStart, batchEnd: new Date() })
-      batchNo++
-    })
-    .run()
-
-  return dest === false ? data : { file, count }
-}
-
-export default importFrom

package/lib/io-exts.js

@@ -1 +0,0 @@
-export default ['.json', '.jsonl', '.ndjson', '.csv', '.xlsx', '.tsv']