@questwork/q-utilities 0.1.34 → 0.1.35

package/dist/q-utilities.cjs

@@ -1954,10 +1954,280 @@ function downloadFileByUrl({ dataUrl = "", filename = "" } = {}) {
 function escapeRegex(string) {
   return String(string).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
+function init(_class, options) {
+  if (options instanceof _class) {
+    return options;
+  }
+  try {
+    const instance2 = new _class(options);
+    return instance2.isValid !== false ? instance2 : null;
+  } catch (e) {
+    console.log(`init failed for class: ${_class._classname || "no _classname"}`, e);
+    return null;
+  }
+}
+function initFromArray(_class, arr) {
+  if (Array.isArray(arr)) {
+    return arr.map((a) => init(_class, a));
+  }
+  return [];
+}
+function initOnlyValidFromArray(_class, arr) {
+  return initFromArray(_class, arr).filter((i) => i);
+}
+const DATAWRAPPER_STATUS = {
+  ORPHAN_DELETED: "orphanDeleted",
+  EXISTED: "existed",
+  FAILED: "failed",
+  INSERTED: "inserted",
+  SKIPPED: "skipped",
+  UPDATED: "updated"
+};
+const LOG_TYPE = {
+  IGNORE: "IGNORE",
+  DUPLICATED: "DUPLICATED",
+  REQUIRED_ERROR: "REQUIRED_ERROR",
+  TRANSFORM_ERROR: "TRANSFORM_ERROR",
+  CONVERT_ERROR: "CONVERT_ERROR",
+  ORPHAN_DELETE_ERROR: "ORPHAN_DELETE_ERROR",
+  INSERT_ERROR: "INSERT_ERROR",
+  UPDATE_ERROR: "UPDATE_ERROR",
+  SKIPPED: "SKIPPED",
+  INSERTED: "INSERTED",
+  UPDATED: "UPDATED",
+  ORPHAN_DELETED: "ORPHAN_DELETED"
+};
+class DataWrapper {
+  constructor(opts) {
+    this.data = opts.data || {};
+    this.logs = opts.logs || [];
+    this.rawData = opts.rawData || {};
+    this.rowIndex = opts.rowIndex || 0;
+    this.status = opts.status || {
+      orphanDeleted: null,
+      existed: null,
+      failed: null,
+      inserted: null,
+      updated: null
+    };
+    this.transformedData = opts.transformedData || {};
+  }
+  static init(opts) {
+    return init(this, opts);
+  }
+  static initFromArray(arr = []) {
+    return initFromArray(this, arr);
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return initOnlyValidFromArray(this, arr);
+  }
+  get errorLogs() {
+    const excludedTypes = [LOG_TYPE.IGNORE, LOG_TYPE.SKIPPED, LOG_TYPE.DUPLICATED];
+    return this.logs.filter((l) => !excludedTypes.includes(l.type));
+  }
+  get ignoreLog() {
+    return this.logs.find((l) => l.type === LOG_TYPE.IGNORE);
+  }
+  addLog(detail) {
+    this.logs.push({
+      ...detail,
+      rowIndex: this.rowIndex
+    });
+    return this;
+  }
+  addError(detail) {
+    return this.addLog(detail).setFailed();
+  }
+  addOrphanDeleteError(msg) {
+    this.addError({
+      column: "",
+      message: msg || "Delete failed.",
+      type: LOG_TYPE.ORPHAN_DELETE_ERROR
+    });
+    return this;
+  }
+  addInsertError(msg) {
+    this.addError({
+      column: "",
+      message: msg || "Insert failed.",
+      type: LOG_TYPE.INSERT_ERROR
+    });
+    return this;
+  }
+  addUpdateError(msg) {
+    this.addError({
+      column: "",
+      message: msg || "Update failed.",
+      type: LOG_TYPE.UPDATE_ERROR
+    });
+    return this;
+  }
+  addDuplicatedLog(msg) {
+    return this.addLog({
+      column: "",
+      message: msg || "Duplicated.",
+      type: LOG_TYPE.DUPLICATED
+    });
+  }
+  addSkippedLog(msg) {
+    return this.addLog({
+      column: "",
+      message: msg || "Skipped.",
+      type: LOG_TYPE.SKIPPED
+    }).setSkipped();
+  }
+  addIgnoreLog(msg) {
+    this.logs = this.logs.filter((l) => l.type !== LOG_TYPE.IGNORE);
+    return this.addLog({
+      column: "",
+      message: msg || "Ignored.",
+      type: LOG_TYPE.IGNORE
+    });
+  }
+  addInsertedLog(msg) {
+    return this.addLog({
+      column: "",
+      message: msg || "Inserted.",
+      type: LOG_TYPE.INSERTED
+    }).setInserted();
+  }
+  addUpdatedLog(msg) {
+    return this.addLog({
+      column: "",
+      message: msg || "Updated.",
+      type: LOG_TYPE.UPDATED
+    }).setUpdated();
+  }
+  addOrphanDeletedLog(msg) {
+    return this.addLog({
+      column: "",
+      message: msg || "Orphan deleted.",
+      type: LOG_TYPE.ORPHAN_DELETED
+    }).setOrphanDeleted();
+  }
+  isCheckValid() {
+    return this.errorLogs.length === 0 && !this.ignoreLog && !this.logs.some((l) => l.type === LOG_TYPE.DUPLICATED);
+  }
+  isIgnored() {
+    return !!this.ignoreLog;
+  }
+  isDuplicated() {
+    return this.logs.some((log) => log.type === LOG_TYPE.DUPLICATED);
+  }
+  hasErrors() {
+    return this.errorLogs.length > 0;
+  }
+  setStatus(status) {
+    this.status[DATAWRAPPER_STATUS[status]] = Date.now();
+    return this;
+  }
+  setExisted() {
+    this.setStatus("EXISTED");
+    return this;
+  }
+  setFailed() {
+    this.setStatus("FAILED");
+    return this;
+  }
+  setInserted() {
+    this.setStatus("INSERTED");
+    return this;
+  }
+  setSkipped() {
+    this.setStatus("SKIPPED");
+    return this;
+  }
+  setUpdated() {
+    this.setStatus("UPDATED");
+    return this;
+  }
+  setOrphanDeleted() {
+    this.setStatus("ORPHAN_DELETED");
+    return this;
+  }
+  setData(data) {
+    this.data = data;
+    return this;
+  }
+  setRawData(rawData) {
+    this.rawData = rawData;
+    return this;
+  }
+  setTransformedData(transformedData) {
+    this.transformedData = transformedData;
+    return this;
+  }
+}
+class DataSet {
+  constructor(opts) {
+    opts = opts || {};
+    this.name = opts.name || "";
+    this.data = DataWrapper.initOnlyValidFromArray(opts.data || []);
+    this.orphanData = DataWrapper.initOnlyValidFromArray(opts.orphanData || []);
+    this.checkResultConfig = opts.checkResultConfig ? { ...opts.checkResultConfig } : {};
+    this.checkResultConfig.hidden = this.checkResultConfig.hidden ?? false;
+    this.saveResultConfig = opts.saveResultConfig ? { ...opts.saveResultConfig } : {};
+    this.saveResultConfig.hidden = this.saveResultConfig.hidden ?? false;
+    this.orphanBehavior = opts.orphanBehavior ?? null;
+    this.notExistBehavior = opts.notExistBehavior;
+    this.existBehavior = opts.existBehavior;
+  }
+  static init(opts) {
+    return init(this, opts);
+  }
+  static initFromArray(arr = []) {
+    return initFromArray(this, arr);
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return initOnlyValidFromArray(this, arr);
+  }
+  add(data) {
+    this.data.push(data);
+    return this;
+  }
+  getExistedData() {
+    return this.data.filter((item) => {
+      var _a;
+      return item.isCheckValid() && ((_a = item.status) == null ? void 0 : _a.existed);
+    });
+  }
+  getInvalidData() {
+    return this.data.filter((item) => !item.isCheckValid());
+  }
+  getNotExistedData() {
+    return this.data.filter((item) => {
+      var _a;
+      return item.isCheckValid() && !((_a = item.status) == null ? void 0 : _a.existed);
+    });
+  }
+  getSkipData() {
+    return this.data.filter((item) => item.isIgnored() || item.isDuplicated());
+  }
+  addOrphan(data) {
+    const dataWrapper = new DataWrapper({
+      data,
+      rowIndex: -1
+    });
+    this.orphanData.push(dataWrapper);
+    return this;
+  }
+  getOrphanData() {
+    return this.orphanData;
+  }
+}
 class CheckResult {
   constructor(opts) {
     this.dataSets = [];
-    this.dataSets = (opts == null ? void 0 : opts.dataSets) || [];
+    this.dataSets = DataSet.initOnlyValidFromArray((opts == null ? void 0 : opts.dataSets) || []);
+  }
+  static init(opts) {
+    return init(this, opts);
+  }
+  static initFromArray(arr = []) {
+    return initFromArray(this, arr);
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return initOnlyValidFromArray(this, arr);
   }
   addDataSet(dataSet) {
     this.dataSets.push(dataSet);
@@ -1965,16 +2235,21 @@ class CheckResult {
   getDataSetByName(name) {
     return this.dataSets.find((dataSet) => dataSet.name === name);
   }
+  getAllSummary() {
+    return {
+      summary: this.getSummary()
+    };
+  }
   getSummary() {
     return this.dataSets.map((dataSet) => ({
       name: dataSet.name,
       hidden: dataSet.checkResultConfig.hidden,
       summary: {
         total: dataSet.data.length,
-        valid: dataSet.data.filter((row) => row.errorLogs.length === 0 && !row.ignoreLog).length,
-        ignored: dataSet.data.filter((row) => row.ignoreLog).length,
-        invalid: dataSet.data.filter((row) => row.errorLogs.length > 0 && !row.errorLogs.some((detail) => detail.type === "DUPLICATED")).length,
-        duplicated: dataSet.data.filter((row) => row.errorLogs.some((detail) => detail.type === "DUPLICATED")).length
+        ignored: dataSet.data.filter((row) => row.isIgnored()).length,
+        duplicated: dataSet.data.filter((row) => !row.isIgnored() && row.isDuplicated()).length,
+        invalid: dataSet.data.filter((row) => !row.isIgnored() && !row.isDuplicated() && row.hasErrors()).length,
+        valid: dataSet.data.filter((row) => row.isCheckValid()).length
       }
     }));
   }
@@ -1982,8 +2257,8 @@ class CheckResult {
     return this.dataSets.map((dataSet) => ({
       name: dataSet.name,
       hidden: dataSet.checkResultConfig.hidden,
-      logs: dataSet.data.filter((row) => row.errorLogs.some((detail) => detail.type === "DUPLICATED")).reduce((acc, row) => {
-        return [...acc, ...row.errorLogs];
+      logs: dataSet.data.filter((row) => row.logs.some((detail) => detail.type === LOG_TYPE.DUPLICATED)).reduce((acc, row) => {
+        return [...acc, ...row.logs.filter((detail) => detail.type === LOG_TYPE.DUPLICATED)];
       }, [])
     }));
   }
@@ -2000,21 +2275,33 @@ class CheckResult {
     return this.dataSets.map((dataSet) => ({
       name: dataSet.name,
       hidden: dataSet.checkResultConfig.hidden,
-      logs: dataSet.data.filter((row) => row.errorLogs.length > 0 && !row.errorLogs.some((detail) => detail.type === "DUPLICATED")).reduce((acc, row) => {
+      logs: dataSet.data.filter((row) => row.errorLogs.length > 0).reduce((acc, row) => {
         return [...acc, ...row.errorLogs];
       }, [])
     }));
   }
   getValidDetails() {
     return this.dataSets.reduce((acc, dataSet) => {
-      acc[dataSet.name] = dataSet.data.filter((row) => row.errorLogs.length === 0).reduce((acc2, row) => {
+      acc[dataSet.name] = dataSet.data.filter((row) => row.isCheckValid()).reduce((acc2, row) => {
         return [...acc2, row];
       }, []);
       return acc;
     }, {});
   }
+  getAllDetails() {
+    return {
+      details: this.getDetails()
+    };
+  }
+  getDetails() {
+    return {
+      ignoredDetails: this.getIgnoredDetails(),
+      invalidDetails: this.getInvalidDetails(),
+      duplicatedDetails: this.getDuplicatedDetails()
+    };
+  }
   hasInvalidData() {
-    return this.dataSets.some((dataSet) => dataSet.data.some((row) => row.errorLogs.length > 0 && !row.errorLogs.some((detail) => detail.type === "DUPLICATED")));
+    return this.dataSets.some((dataSet) => dataSet.data.some((row) => row.errorLogs.length > 0));
   }
 }
 class SaveResult {
@@ -2027,11 +2314,112 @@ class SaveResult {
     this.dataSets.push(dataSet);
     return this;
   }
+  getAllDetails() {
+    return {
+      details: this.getDetails(),
+      orphanDetails: this.getOrphanDetails()
+    };
+  }
+  getDetails() {
+    return {
+      failed: this.getFailedDetails(),
+      skipped: this.getSkippedDetails(),
+      inserted: this.getInsertedDetails(),
+      updated: this.getUpdatedDetails()
+    };
+  }
+  getFailedDetails() {
+    const types = [LOG_TYPE.INSERT_ERROR, LOG_TYPE.UPDATE_ERROR];
+    return this.dataSets.map((dataSet) => {
+      return {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        logs: dataSet.data.filter((row) => row.logs.some((detail) => types.includes(detail.type))).reduce((acc, row) => {
+          return acc.concat(row.logs.filter((detail) => types.includes(detail.type)));
+        }, [])
+      };
+    });
+  }
+  getSkippedDetails() {
+    const types = [LOG_TYPE.SKIPPED, LOG_TYPE.IGNORE, LOG_TYPE.DUPLICATED];
+    return this.dataSets.map((dataSet) => {
+      return {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        logs: dataSet.data.reduce((acc, row) => {
+          const filtered = row.logs.filter((detail) => types.includes(detail.type));
+          return acc.concat(filtered);
+        }, [])
+      };
+    });
+  }
+  getInsertedDetails() {
+    return this.dataSets.map((dataSet) => {
+      return {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        logs: dataSet.data.reduce((acc, row) => {
+          const filtered = row.logs.filter((detail) => detail.type === LOG_TYPE.INSERTED);
+          return acc.concat(filtered);
+        }, [])
+      };
+    });
+  }
+  getUpdatedDetails() {
+    return this.dataSets.map((dataSet) => {
+      return {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        logs: dataSet.data.reduce((acc, row) => {
+          const filtered = row.logs.filter((detail) => detail.type === LOG_TYPE.UPDATED);
+          return acc.concat(filtered);
+        }, [])
+      };
+    });
+  }
+  getOrphanDetails() {
+    return {
+      deleted: this.getOrphanDeletedDetails(),
+      failed: this.getOrphanFailedDetails()
+    };
+  }
+  getOrphanFailedDetails() {
+    return this.dataSets.reduce((acc, dataSet) => {
+      if (dataSet.orphanBehavior) {
+        acc.push({
+          name: dataSet.name,
+          hidden: dataSet.saveResultConfig.hidden,
+          logs: dataSet.orphanData.filter((row) => {
+            var _a;
+            return (_a = row.errorLogs) == null ? void 0 : _a.some((log) => log.type === LOG_TYPE.ORPHAN_DELETE_ERROR);
+          }).reduce((acc2, row) => {
+            return acc2.concat(row.errorLogs);
+          }, [])
+        });
+      }
+      return acc;
+    }, []);
+  }
+  getOrphanDeletedDetails() {
+    return this.dataSets.reduce((acc, dataSet) => {
+      if (dataSet.orphanBehavior) {
+        acc.push({
+          name: dataSet.name,
+          hidden: dataSet.saveResultConfig.hidden,
+          logs: dataSet.orphanData.filter((row) => row.status.orphanDeleted).reduce((acc2, row) => {
+            return acc2.concat(row.errorLogs);
+          }, [])
+        });
+      }
+      return acc;
+    }, []);
+  }
+  // Deprecated, will use getAllDetails instead
   getSaveDetails() {
     return this.dataSets.map((dataSet) => {
       var _a;
       const returnDetail = (_a = dataSet.saveResultConfig) == null ? void 0 : _a.returnDetail;
-      return {
+      const result = {
         name: dataSet.name,
         hidden: dataSet.saveResultConfig.hidden,
         details: {
@@ -2039,140 +2427,89 @@ class SaveResult {
           inserted: (returnDetail == null ? void 0 : returnDetail.inserted) ? dataSet.data.filter((row) => row.status.inserted) : null,
           skipped: (returnDetail == null ? void 0 : returnDetail.skipped) ? dataSet.data.filter((row) => row.status.skipped) : null,
           updated: (returnDetail == null ? void 0 : returnDetail.updated) ? dataSet.data.filter((row) => row.status.updated) : null
-        }
+        },
+        orphanDetails: null
       };
+      if (dataSet.orphanBehavior) {
+        result.orphanDetails = {
+          deleted: (returnDetail == null ? void 0 : returnDetail.orphanDeleted) ? dataSet.orphanData.filter((row) => row.status.orphanDeleted) : [],
+          failed: dataSet.orphanData.filter((row) => {
+            var _a2;
+            return (_a2 = row.errorLogs) == null ? void 0 : _a2.some((log) => log.type === LOG_TYPE.ORPHAN_DELETE_ERROR);
+          })
+        };
+      }
+      return result;
     });
   }
+  // Deprecated, will use getAllSummary instead
   getSaveSummary() {
-    return this.dataSets.map((dataSet) => ({
-      name: dataSet.name,
-      hidden: dataSet.saveResultConfig.hidden,
-      summary: {
-        total: dataSet.data.length,
-        failed: dataSet.data.filter((row) => row.status.failed).length,
-        inserted: dataSet.data.filter((row) => row.status.inserted).length,
-        skipped: dataSet.data.filter((row) => row.status.skipped).length,
-        updated: dataSet.data.filter((row) => row.status.updated).length
+    return this.dataSets.map((dataSet) => {
+      const result = {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        summary: {
+          total: dataSet.data.length,
+          failed: dataSet.data.filter((row) => row.status.failed).length,
+          inserted: dataSet.data.filter((row) => row.status.inserted).length,
+          skipped: dataSet.data.filter((row) => row.status.skipped).length,
+          updated: dataSet.data.filter((row) => row.status.updated).length
+        },
+        orphanSummary: null
+      };
+      if (dataSet.orphanBehavior) {
+        result.orphanSummary = {
+          total: dataSet.orphanData.length,
+          deleted: dataSet.orphanData.filter((row) => row.status.orphanDeleted).length,
+          failed: dataSet.orphanData.filter((row) => {
+            var _a;
+            return (_a = row.errorLogs) == null ? void 0 : _a.some((log) => log.type === LOG_TYPE.ORPHAN_DELETE_ERROR);
+          }).length
+        };
       }
-    }));
-  }
-}
-class DataSet {
-  constructor(opts) {
-    opts = opts || {};
-    this.name = opts.name || "";
-    this.data = opts.data || [];
-    this.checkResultConfig = opts.checkResultConfig ? { ...opts.checkResultConfig } : {};
-    this.checkResultConfig.hidden = this.checkResultConfig.hidden ?? false;
-    this.saveResultConfig = opts.saveResultConfig ? { ...opts.saveResultConfig } : {};
-    this.saveResultConfig.hidden = this.saveResultConfig.hidden ?? false;
-  }
-  add(data) {
-    this.data.push(data);
-    return this;
-  }
-  getExistedData() {
-    return this.data.filter((item) => {
-      var _a;
-      return item.isValid() && ((_a = item.status) == null ? void 0 : _a.existed);
-    });
-  }
-  getInvalidData() {
-    return this.data.filter((item) => !item.isValid());
-  }
-  getNotExistedData() {
-    return this.data.filter((item) => {
-      var _a;
-      return item.isValid() && !((_a = item.status) == null ? void 0 : _a.existed);
+      return result;
     });
   }
-}
-const DATAWRAPPER_STATUS = {
-  EXISTED: "existed",
-  FAILED: "failed",
-  INSERTED: "inserted",
-  SKIPPED: "skipped",
-  UPDATED: "updated"
-};
-class DataWrapper {
-  constructor(opts) {
-    this.data = opts.data || {};
-    this.errorLogs = opts.errorLogs || [];
-    this.ignoreLog = opts.ignoreLog;
-    this.rawData = opts.rawData || {};
-    this.rowIndex = opts.rowIndex || 0;
-    this.status = opts.status || {
-      existed: null,
-      failed: null,
-      inserted: null,
-      updated: null
+  getAllSummary() {
+    return {
+      summary: this.getSummary(),
+      orphanSummary: this.getOrphanSummary()
     };
-    this.transformedData = opts.transformedData || {};
   }
-  addError(detail) {
-    this.errorLogs.push(detail);
-    return this;
-  }
-  addInsertError(msg) {
-    this.addError({
-      rowIndex: this.rowIndex,
-      column: "",
-      message: msg,
-      type: "INSERT_ERROR"
-    });
-    return this;
-  }
-  addUpdateError(msg) {
-    this.addError({
-      rowIndex: this.rowIndex,
-      column: "",
-      message: msg,
-      type: "UPDATE_ERROR"
+  getSummary() {
+    return this.dataSets.map((dataSet) => {
+      const result = {
+        name: dataSet.name,
+        hidden: dataSet.saveResultConfig.hidden,
+        summary: {
+          total: dataSet.data.length,
+          failed: dataSet.data.filter((row) => row.status.failed).length,
+          inserted: dataSet.data.filter((row) => row.status.inserted).length,
+          skipped: dataSet.data.filter((row) => row.status.skipped).length,
+          updated: dataSet.data.filter((row) => row.status.updated).length
+        }
+      };
+      return result;
     });
-    return this;
-  }
-  isValid() {
-    return this.errorLogs.length === 0 && !this.ignoreLog;
-  }
-  setIgnoreLog(detail) {
-    this.ignoreLog = detail;
-    return this;
-  }
-  setData(data) {
-    this.data = data;
-    return this;
-  }
-  setExisted() {
-    this.setStatus("EXISTED");
-    return this;
-  }
-  setFailed() {
-    this.setStatus("FAILED");
-    return this;
-  }
-  setInserted() {
-    this.setStatus("INSERTED");
-    return this;
-  }
-  setRawData(rawData) {
-    this.rawData = rawData;
-    return this;
-  }
-  setSkipped() {
-    this.setStatus("SKIPPED");
-    return this;
-  }
-  setStatus(status) {
-    this.status[DATAWRAPPER_STATUS[status]] = Date.now();
-    return this;
   }
-  setTransformedData(transformedData) {
-    this.transformedData = transformedData;
-    return this;
-  }
-  setUpdated() {
-    this.setStatus("UPDATED");
-    return this;
+  getOrphanSummary() {
+    return this.dataSets.reduce((acc, dataSet) => {
+      if (dataSet.orphanBehavior) {
+        acc.push({
+          name: dataSet.name,
+          hidden: dataSet.saveResultConfig.hidden,
+          summary: {
+            total: dataSet.orphanData.length,
+            deleted: dataSet.orphanData.filter((row) => row.status.orphanDeleted).length,
+            failed: dataSet.orphanData.filter((row) => {
+              var _a;
+              return (_a = row.errorLogs) == null ? void 0 : _a.some((log) => log.type === LOG_TYPE.ORPHAN_DELETE_ERROR);
+            }).length
+          }
+        });
+      }
+      return acc;
+    }, []);
   }
 }
 class ExcelImportHelper {
@@ -2188,7 +2525,7 @@ class ExcelImportHelper {
       if (!worksheetData) continue;
       const worksheet = config.worksheets.find((item) => item.name === worksheetName);
       const dataSources = (worksheet == null ? void 0 : worksheet.dataSources) || [];
-      const { headerRow = 1, dataStartRow = 2 } = worksheet || {};
+      const { headerRow = 1, dataStartRow = 2, rowIndexKey } = worksheet || {};
       for (const dataSource of dataSources) {
         if (!dataSource.headerConfigs || !dataSource.name) continue;
         const seenPrimaryKeys = /* @__PURE__ */ new Map();
@@ -2201,9 +2538,10 @@ class ExcelImportHelper {
         for (let rowIndex = 0; rowIndex < worksheetData.length; rowIndex++) {
           const row = worksheetData[rowIndex];
           const rawData = this.getRawDataFromHeaders(row, dataSource.headerConfigs);
-          let excelRow = this.createExcelRow(rawData, rowIndex + dataStartRow);
+          let excelRow = this.createExcelRow(rawData, getRowIndex(row, rowIndexKey));
           const ctx = Object.assign({ dataSets: result.dataSets }, context);
           const handlers = [
+            (row2) => this.checkRequired(row2, dataSource.headerConfigs, headers),
             (row2) => this.checkDuplicated(row2, dataSource, seenPrimaryKeys),
             (row2) => this.isIgnore(row2, ctx, dataSource.isIgnore),
             (row2) => this.transform(row2, dataSource.headerConfigs, headers),
@@ -2211,7 +2549,7 @@ class ExcelImportHelper {
           ];
           for (const handler of handlers) {
             excelRow = handler(excelRow);
-            if (excelRow.errorLogs.length > 0 || excelRow.ignoreLog) {
+            if (excelRow.errorLogs.length > 0 || excelRow.ignoreLog || excelRow.isDuplicated()) {
               break;
             }
           }
@@ -2225,10 +2563,9 @@ class ExcelImportHelper {
   }
   static createExcelRow(row, rowIndex) {
     return new DataWrapper({
-      // data: { ...row },
       rawData: row,
       rowIndex,
-      errorLogs: []
+      logs: []
     });
   }
   static getRawDataFromHeaders(excelRow, headerConfigs = []) {
@@ -2244,25 +2581,28 @@ class ExcelImportHelper {
     }
     const { ignore, reason } = isIgnore({ rawData: row.rawData, rowIndex: row.rowIndex, ctx });
     if (ignore) {
-      row.setIgnoreLog({
-        rowIndex: row.rowIndex,
-        column: "",
-        message: reason || "",
-        type: "IGNORE"
-      });
+      row.addIgnoreLog(reason || "");
+    }
+    return row;
+  }
+  static checkRequired(row, headerConfigs = [], headers = []) {
+    const rawData = { ...row.rawData };
+    for (const config of headerConfigs) {
+      const value = rawData[config.name];
+      if (config.required && (value === null || value === void 0 || value === "")) {
+        row.addError({
+          column: getExcelColumnName(headers.indexOf(config.name)),
+          message: `${config.name} is required.`,
+          type: LOG_TYPE.REQUIRED_ERROR
+        });
+      }
     }
     return row;
   }
   static checkDuplicated(row, dataSource, seenPrimaryKeys) {
     const primaryKey = dataSource.primaryKeys.map((key) => row.rawData[key]).join("-");
     if (seenPrimaryKeys.has(primaryKey)) {
-      row.addError({
-        rowIndex: row.rowIndex,
-        // column: getPrimaryKeyColumn(dataSource.primaryKeys, headers),
-        column: "",
-        message: `Duplicated with row ${seenPrimaryKeys.get(primaryKey) || 0}`,
-        type: "DUPLICATED"
-      });
+      row.addDuplicatedLog(`Duplicated with row ${seenPrimaryKeys.get(primaryKey) || 0}.`);
     } else {
       seenPrimaryKeys.set(primaryKey, row.rowIndex);
     }
@@ -2272,26 +2612,13 @@ class ExcelImportHelper {
     const rawData = { ...row.rawData };
     const transformedData = {};
     for (const config of headerConfigs) {
-      const value = rawData[config.name];
-      let hasRequiredError = false;
-      if (config.required && (value === null || value === void 0 || value === "")) {
-        row.addError({
-          rowIndex: row.rowIndex,
-          column: getExcelColumnName(headers.indexOf(config.name)),
-          message: `${config.name} is required`,
-          type: "REQUIRED"
-        });
-        hasRequiredError = true;
-      }
-      if (hasRequiredError) continue;
       try {
         transformedData[config.name] = typeof config.transform === "function" ? config.transform(rawData[config.name]) : rawData[config.name];
       } catch (error) {
         row.addError({
-          rowIndex: row.rowIndex,
           column: getExcelColumnName(headers.indexOf(config.name)),
-          message: `transform ${config.name} failed`,
-          type: "TRANSFORM"
+          message: `Transform ${config.name} failed: ${error.message}`,
+          type: LOG_TYPE.TRANSFORM_ERROR
         });
       }
     }
@@ -2309,10 +2636,9 @@ class ExcelImportHelper {
       return row.setData(result);
     } catch (error) {
       row.addError({
-        rowIndex: row.rowIndex,
         column: "",
-        message: `convert failed`,
-        type: "CONVERT"
+        message: `Convert failed: ${error.message}`,
+        type: LOG_TYPE.CONVERT_ERROR
       });
     }
     return row;
@@ -2338,6 +2664,9 @@ class ExcelImportHelper {
         if (checkExisted && typeof checkExisted === "function") {
           updatedDataSet = await checkExisted({ dataSet: updatedDataSet, ctx });
         }
+        if (dataSource.orphanBehavior === "DELETE" && dataSource.checkOrphans && typeof dataSource.checkOrphans === "function") {
+          await dataSource.checkOrphans({ dataSet: updatedDataSet, ctx });
+        }
         if (handleData && typeof handleData === "function") {
           updatedDataSet = await handleData({ dataSet: updatedDataSet, dataSource, ctx });
         } else {
@@ -2360,6 +2689,9 @@ function getExcelColumnName(columnIndex) {
   }
   return result;
 }
+function getRowIndex(row, rowIndexKey) {
+  return row[rowIndexKey || "__rowNum"] || 0;
+}
 function customHandler({ responseHelper, handler, ignoreError = false }) {
   return async (reqOrCtx, resOrNext, nextInExpress) => {
     const isKoa = typeof resOrNext === "function" && !nextInExpress;
@@ -2622,6 +2954,26 @@ class Repo {
     }
     return options;
   }
+  async bulkWriteDocs({ operations, config, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: "REPO_BULK_WRITE",
+      message: `fn ${this._classname}.prototype.bulkWriteDocs`,
+      input: [{ operations: { ...operations }, config: { ...config }, systemLog: { ...systemLog } }]
+    });
+    const sharedOptions = {
+      ...this._sharedOptions,
+      ...config
+    };
+    try {
+      const result = await this.model.bulkWriteDocs(operations, sharedOptions);
+      log({ level: "info", output: { ...result } });
+      return result;
+    } catch (err) {
+      log({ level: "warn", output: err.toString() });
+      throw err;
+    }
+  }
   async deleteOne({ id }) {
     try {
       const result = await this.model.deleteOne({ _id: id });
@@ -2905,6 +3257,27 @@ function makeService({ repo }) {
   }
   return new Service({ repo });
 }
+class ServiceBulkWrite extends Service {
+  constructor({ repo }) {
+    super({ repo });
+  }
+  static get _classname() {
+    return "ServiceBulkWrite";
+  }
+  async bulkWriteDocs({ operations, config }) {
+    const result = await this.repo.bulkWriteDocs({ operations, config });
+    return result;
+  }
+}
+function makeServiceBulkWrite({ repo }) {
+  if (repo === void 0) {
+    throw new Error("repo is required.");
+  }
+  if (repo._superclass !== Repo._superclass) {
+    throw new Error("repo is not an instance of Repo.");
+  }
+  return new ServiceBulkWrite({ repo });
+}
 async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator: UniqueKeyGenerator2, resourceInfo }) {
   const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body;
   const _resourceInfo = resourceInfo || body.resourceInfo;
@@ -3025,27 +3398,6 @@ function groupArrayByKey(arr, key) {
     return acc;
   }, {});
 }
-function init(_class, options) {
-  if (options instanceof _class) {
-    return options;
-  }
-  try {
-    const instance2 = new _class(options);
-    return instance2.isValid !== false ? instance2 : null;
-  } catch (e) {
-    console.log(`init failed for class: ${_class._classname || "no _classname"}`, e);
-    return null;
-  }
-}
-function initFromArray(_class, arr) {
-  if (Array.isArray(arr)) {
-    return arr.map((a) => init(_class, a));
-  }
-  return [];
-}
-function initOnlyValidFromArray(_class, arr) {
-  return initFromArray(_class, arr).filter((i) => i);
-}
 function mergeArraysByKey(arr1, arr2) {
   const safeArr1 = Array.isArray(arr1) ? arr1 : [];
   const safeArr2 = Array.isArray(arr2) ? arr2 : [];
@@ -3636,6 +3988,7 @@ const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   __proto__: null,
   CheckResult,
   ExcelImportHelper,
+  LOG_TYPE,
   authorize,
   calculateAge,
   changeCreatorOwner,
@@ -4751,6 +5104,7 @@ const models = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   QMeta,
   Repo,
   Service,
+  ServiceBulkWrite,
   Status,
   StatusDocument,
   TemplateCompiler,
@@ -4761,7 +5115,8 @@ const models = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   WebAppResponse,
   getQLogEnv,
   makeApiResponse,
-  makeService
+  makeService,
+  makeServiceBulkWrite
 }, Symbol.toStringTag, { value: "Module" }));
 const index = {
   ...helpers,
@@ -4776,6 +5131,7 @@ exports.ERROR_CODES = ERROR_CODES;
 exports.ErrorDetail = ErrorDetail;
 exports.ExcelImportHelper = ExcelImportHelper;
 exports.KeyValueObject = KeyValueObject;
+exports.LOG_TYPE = LOG_TYPE;
 exports.LogRecord = LogRecord;
 exports.Metadata = Metadata;
 exports.PushEnvelope = PushEnvelope;
@@ -4785,6 +5141,7 @@ exports.QLogLevel = QLogLevel;
 exports.QMeta = QMeta;
 exports.Repo = Repo;
 exports.Service = Service;
+exports.ServiceBulkWrite = ServiceBulkWrite;
 exports.Status = Status;
 exports.StatusDocument = StatusDocument;
 exports.TemplateCompiler = TemplateCompiler;
@@ -4819,6 +5176,7 @@ exports.initOnlyValidFromArray = initOnlyValidFromArray;
 exports.isConvertibleToNumber = isConvertibleToNumber;
 exports.makeApiResponse = makeApiResponse;
 exports.makeService = makeService;
+exports.makeServiceBulkWrite = makeServiceBulkWrite;
 exports.mergeArraysByKey = mergeArraysByKey;
 exports.objectHelper = objectHelper;
 exports.pMap = pMap;