@questwork/q-utilities 0.1.34 → 0.1.36

package/dist/q-utilities.umd.js

@@ -1956,10 +1956,280 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
   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);
@@ -1967,16 +2237,21 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
     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
         }
       }));
     }
@@ -1984,8 +2259,8 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       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)];
         }, [])
       }));
     }
@@ -2002,21 +2277,33 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       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 {
@@ -2029,11 +2316,112 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       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: {
@@ -2041,140 +2429,89 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
             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 {
@@ -2190,7 +2527,7 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
         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();
@@ -2198,14 +2535,18 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
             name: dataSource.name,
             data: [],
             checkResultConfig: dataSource.checkResultConfig,
-            saveResultConfig: dataSource.saveResultConfig
+            saveResultConfig: dataSource.saveResultConfig,
+            orphanBehavior: dataSource.orphanBehavior,
+            notExistBehavior: dataSource.notExistBehavior,
+            existBehavior: dataSource.existBehavior
           });
           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),
@@ -2213,7 +2554,7 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
             ];
             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;
               }
             }
@@ -2227,10 +2568,9 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
     }
     static createExcelRow(row, rowIndex) {
       return new DataWrapper({
-        // data: { ...row },
         rawData: row,
         rowIndex,
-        errorLogs: []
+        logs: []
       });
     }
     static getRawDataFromHeaders(excelRow, headerConfigs = []) {
@@ -2246,25 +2586,28 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       }
       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);
       }
@@ -2274,26 +2617,13 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       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
           });
         }
       }
@@ -2311,10 +2641,9 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
         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;
@@ -2340,6 +2669,9 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
           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 {
@@ -2362,6 +2694,9 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
     }
     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;
@@ -2624,6 +2959,26 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       }
       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 });
@@ -2907,6 +3262,27 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
     }
     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;
@@ -3027,27 +3403,6 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
       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 : [];
@@ -3638,6 +3993,7 @@ ${index2 + 1}. Character: ${JSON.stringify(match.character)}`);
     __proto__: null,
     CheckResult,
     ExcelImportHelper,
+    LOG_TYPE,
     authorize,
     calculateAge,
     changeCreatorOwner,
@@ -4753,6 +5109,7 @@ ${this.zone || ""}`;
     QMeta,
     Repo,
     Service,
+    ServiceBulkWrite,
     Status,
     StatusDocument,
     TemplateCompiler,
@@ -4763,7 +5120,8 @@ ${this.zone || ""}`;
     WebAppResponse,
     getQLogEnv,
     makeApiResponse,
-    makeService
+    makeService,
+    makeServiceBulkWrite
   }, Symbol.toStringTag, { value: "Module" }));
   const index = {
     ...helpers,
@@ -4778,6 +5136,7 @@ ${this.zone || ""}`;
   exports2.ErrorDetail = ErrorDetail;
   exports2.ExcelImportHelper = ExcelImportHelper;
   exports2.KeyValueObject = KeyValueObject;
+  exports2.LOG_TYPE = LOG_TYPE;
   exports2.LogRecord = LogRecord;
   exports2.Metadata = Metadata;
   exports2.PushEnvelope = PushEnvelope;
@@ -4787,6 +5146,7 @@ ${this.zone || ""}`;
   exports2.QMeta = QMeta;
   exports2.Repo = Repo;
   exports2.Service = Service;
+  exports2.ServiceBulkWrite = ServiceBulkWrite;
   exports2.Status = Status;
   exports2.StatusDocument = StatusDocument;
   exports2.TemplateCompiler = TemplateCompiler;
@@ -4821,6 +5181,7 @@ ${this.zone || ""}`;
   exports2.isConvertibleToNumber = isConvertibleToNumber;
   exports2.makeApiResponse = makeApiResponse;
   exports2.makeService = makeService;
+  exports2.makeServiceBulkWrite = makeServiceBulkWrite;
   exports2.mergeArraysByKey = mergeArraysByKey;
   exports2.objectHelper = objectHelper;
   exports2.pMap = pMap;