@xuda.io/xuda-worker-bundle-min 1.3.816 → 1.3.818

package/index.js

@@ -25,9 +25,9 @@ glb.PROTECTED_VARS = [
   "_THIS",
   "_FOR_KEY",
   "_FOR_VAL",
-  "_ROW_NO",
-  "_ROW_ID",
-  "_ROW_DOC",
+  "_ROWNO",
+  "_ROWID",
+  "_ROWDOC",
   "_KEY",
   "_VAL",
 ];
@@ -43,7 +43,22 @@ func.common.find_item_by_key_root = function (arr, key, val) {
     return e[key] === val;
   });
 };
+func.common.find_ROWID_idx = function (_ds, rowId) {
+  if (!_ds?.data_feed?.rows) {
+    throw new Error("data_feed not found");
+  }
+
+  // Find the index of the object with the given _ROWID
+  const index = _ds.data_feed.rows.findIndex((item) => item._ROWID === rowId);
+
+  // If the index is -1, the ROWID was not found, so throw an error
+  if (index === -1) {
+    throw new Error(`ROWID "${rowId}" not found`);
+  }
 
+  // Return the found index
+  return index;
+};
 func.common.input_mask = async function (
   actionP,
   valP,
@@ -1930,7 +1945,7 @@ func.datasource.prepare = async function (
 
         delete _ds.v.old_dataSource; // to eliminate parse error
         delete _ds.rows_found;
-        _ds.raw_data = {};
+        // _ds.raw_data = {};
         _ds.data_feed = {};
 
         _ds.v.old_dataSource = _.cloneDeep(_ds);
@@ -2137,10 +2152,15 @@ func.datasource.execute = async function (
       return false;
     }
     _ds.v.batch_loops =
-      (await get_limit()) <= _ds.v?.raw_data?.rows?.length
+      (await get_limit()) <= _ds.data_feed?.rows?.length
         ? await get_limit()
-        : _ds.v?.raw_data?.rows?.length;
+        : _ds?.data_feed?.rows?.length;
     return true;
+    // _ds.v.batch_loops =
+    //   (await get_limit()) <= _ds.v?.raw_data?.rows?.length
+    //     ? await get_limit()
+    //     : _ds.v?.raw_data?.rows?.length;
+    // return true;
   };
 
   const render_api_output = async function () {
@@ -2314,7 +2334,8 @@ func.datasource.execute = async function (
         filterModelUserMongo: _ds.progDataSource.filterModelUserMongo,
         filterModelUserSql: _ds.progDataSource.filterModelUserSql,
       };
-      _ds.v.raw_data = await func.db.get_query(
+
+      _ds.data_feed = await func.db.get_query(
         SESSION_ID,
         _ds._dataSourceTableId,
         _ds.v.couchView,
@@ -2331,6 +2352,23 @@ func.datasource.execute = async function (
         filterModel
       );
 
+      // _ds.v.raw_data = await func.db.get_query(
+      //   SESSION_ID,
+      //   _ds._dataSourceTableId,
+      //   _ds.v.couchView,
+      //   dataSourceSession,
+      //   _ds.viewSourceDesc,
+      //   "datasource table",
+      //   prog_obj.progDataSource.dataSourceReduce,
+      //   await get_skip(),
+      //   (await get_limit()) || 99999999,
+      //   null,
+      //   null,
+      //   _ds?.progDataSource?.sortModel,
+      //   null,
+      //   filterModel
+      // );
+
       const ret_rows_found = await func.db.get_query(
         SESSION_ID,
         _ds._dataSourceTableId,
@@ -2358,14 +2396,19 @@ func.datasource.execute = async function (
         data = [];
       }
 
-      if (!_ds.v.raw_data) {
-        _ds.v.raw_data = { rows: [] };
-      }
       let _KEY = 0;
       for (const _VAL of data) {
-        _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+        _ds.data_feed.rows[_KEY] = { _KEY, _VAL };
         _KEY++;
       }
+      // if (!_ds.v.raw_data) {
+      //   _ds.v.raw_data = { rows: [] };
+      // }
+      // let _KEY = 0;
+      // for (const _VAL of data) {
+      //   _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+      //   _KEY++;
+      // }
       break;
     }
 
@@ -2375,13 +2418,16 @@ func.datasource.execute = async function (
         data = {};
       }
 
-      if (!_ds.v.raw_data) {
-        _ds.v.raw_data = { rows: [] };
-      }
-
       for (let [_KEY, _VAL] of Object.keys(data)) {
-        _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+        _ds.data_feed.rows[_KEY] = { _KEY, _VAL };
       }
+      // if (!_ds.v.raw_data) {
+      //   _ds.v.raw_data = { rows: [] };
+      // }
+
+      // for (let [_KEY, _VAL] of Object.keys(data)) {
+      //   _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+      // }
 
       break;
     }
@@ -2399,9 +2445,19 @@ func.datasource.execute = async function (
       let _KEY = 0;
       let arr = data.split(",");
       for (const _VAL of arr) {
-        _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+        _ds.data_feed.rows[_KEY] = { _KEY, _VAL };
         _KEY++;
       }
+      // if (!_ds.v.raw_data) {
+      //   _ds.v.raw_data = { rows: [] };
+      // }
+
+      // let _KEY = 0;
+      // let arr = data.split(",");
+      // for (const _VAL of arr) {
+      //   _ds.v.raw_data.rows[_KEY] = { id: _KEY, value: { _KEY, _VAL } };
+      //   _KEY++;
+      // }
 
       break;
 
@@ -2435,10 +2491,10 @@ func.datasource.execute = async function (
       _ds.api_rendered_output = "";
       let has_datasource = await calc_batch_loops();
 
-      data_arr = _ds.v?.raw_data?.rows || [];
+      data_arr = _ds.data_feed.rows || [];
       if (!has_datasource) {
         for (n = 0; n < _ds.v.batch_loops; n++) {
-          data_arr.push({});
+          data_arr.push({ _ROWID: n });
         }
       }
       _ds.currentRecordId = "dataset";
@@ -2446,9 +2502,7 @@ func.datasource.execute = async function (
         if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
 
         if (!has_datasource) {
-          val.value = _ds?.data_feed?.rows?.[_ds.currentRecordId] || {
-            value: {},
-          };
+          val = _ds?.data_feed?.rows?.[key] || { _ROWID: key };
         }
 
         if (await get_before_record_count()) {
@@ -2494,10 +2548,10 @@ func.datasource.execute = async function (
     case "batch": {
       let has_datasource = await calc_batch_loops();
 
-      data_arr = _ds.v?.raw_data?.rows || [];
+      data_arr = _ds?.data_feed?.rows || [];
       if (!has_datasource) {
         for (n = 0; n < _ds.v.batch_loops; n++) {
-          data_arr.push({});
+          data_arr.push({ _ROWID: n });
         }
       }
       _ds.currentRecordId = "dataset";
@@ -2505,9 +2559,7 @@ func.datasource.execute = async function (
         if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
 
         if (!has_datasource) {
-          val.value = _ds?.data_feed?.rows?.[_ds.currentRecordId] || {
-            value: {},
-          };
+          val.value = _ds?.data_feed?.rows?.[key] || { _ROWID: key };
         }
 
         if (await get_before_record_count()) {
@@ -2579,27 +2631,28 @@ func.datasource.execute = async function (
 
       if (tree_obj.crudMode === "U") {
         _ds.set_mode = "U";
-        data_arr = _ds.v?.raw_data?.rows || [];
+        data_arr = _ds?.data_feed?.rows || [];
       }
 
       if (tree_obj.crudMode === "D") {
         _ds.set_mode = "D";
-        data_arr = _ds.v?.raw_data?.rows || [];
+        data_arr = _ds.data_feed?.rows || [];
       }
 
+      const newRecord = 999999;
       // initiated with Update but no rows found
       if (
         tree_obj.crudMode === "U" &&
         tree_obj.allowCreate &&
-        !_ds.v?.raw_data?.rows?.length
+        !_ds?.data_feed?.rows?.length
       ) {
         _ds.set_mode = "C";
-        data_arr = [{ id: "newRecord", value: {} }];
+        data_arr = [{ _ROWID: newRecord }];
       }
 
       if (tree_obj.crudMode === "C") {
         _ds.set_mode = "C";
-        data_arr = [{ id: "newRecord", value: {} }];
+        data_arr = [{ _ROWID: newRecord }];
       }
 
       for await (let val of data_arr) {
@@ -2663,14 +2716,16 @@ func.datasource.execute = async function (
         _ds.set_mode = "C";
         _ds.record_not_found = true;
 
-        if (_.isEmpty(_ds.data_feed.rows["newRecord"])) {
+        const newRecord = 999999;
+
+        if (_.isEmpty(_ds.data_feed.rows[newRecord])) {
           await func.datasource.render_fields_form(
             SESSION_ID,
             dataSourceSession,
-            { id: "newRecord", value: {} },
-            null,
-            false,
-            "newRecord"
+            { _ROWID: newRecord } // { id: "newRecord", value: {} },
+            // null,
+            // false,
+            // "newRecord"
           );
         }
         var count = await func.datasource.get_field_init_count(
@@ -2700,14 +2755,25 @@ func.datasource.execute = async function (
 
       const finish_form = async function () {
         // check if locatedRecordId exist in SESSION_OBJ[SESSION_ID].DS_GLB
-        if (
-          _ds.locatedRecordId &&
-          typeof _ds.data_feed.rows[_ds.locatedRecordId] === "undefined"
-        ) {
-          delete _ds.locatedRecordId;
+        if (_ds.locatedRecordId) {
+          try {
+            const row_idx = func.common.find_ROWID_idx(
+              _ds,
+              _ds.locatedRecordId
+            );
+          } catch (error) {
+            delete _ds.locatedRecordId;
+          }
         }
 
-        db_adapter_module.sort_data(SESSION_ID, dataSourceSession, "form");
+        // if (
+        //   _ds.locatedRecordId &&
+        //   typeof _ds.data_feed.rows[row_idx] === "undefined"
+        // ) {
+        //   delete _ds.locatedRecordId;
+        // }
+
+        // db_adapter_module.sort_data(SESSION_ID, dataSourceSession, "form");
 
         _ds.finalRecordId = func.datasource.get_currentRecordId(
           SESSION_ID,
@@ -2731,7 +2797,7 @@ func.datasource.execute = async function (
         // return await callback_datasource();
       };
 
-      for await (const [key, val] of Object.entries(_ds.v.raw_data.rows)) {
+      for await (const [key, val] of Object.entries(_ds.data_feed.rows)) {
         if (await get_before_record_count()) {
           await func.datasource.execute_view_events(
             SESSION_ID,
@@ -2772,6 +2838,361 @@ func.datasource.execute = async function (
         "E"
       );
   }
+  // switch (tree_obj.menuType) {
+  //   case "api": {
+  //     _ds.api_rendered_output = "";
+  //     let has_datasource = await calc_batch_loops();
+
+  //     data_arr = _ds.v?.raw_data?.rows || [];
+  //     if (!has_datasource) {
+  //       for (n = 0; n < _ds.v.batch_loops; n++) {
+  //         data_arr.push({});
+  //       }
+  //     }
+  //     _ds.currentRecordId = "dataset";
+  //     for await (let [key, val] of Object.entries(data_arr)) {
+  //       if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
+
+  //       if (!has_datasource) {
+  //         val.value = _ds?.data_feed?.rows?.[_ds.currentRecordId] || {
+  //           value: {},
+  //         };
+  //       }
+
+  //       if (await get_before_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "before_record"
+  //         );
+  //       }
+
+  //       await func.datasource.render_fields_dataset(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         val
+  //       );
+
+  //       if (await get_after_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "after_record"
+  //         );
+  //       }
+
+  //       await render_api_output();
+  //     }
+
+  //     if (tree_obj.apiOutput === "json") {
+  //       var str = _ds.api_rendered_output.substring(
+  //         0,
+  //         _ds.api_rendered_output.length - 1
+  //       );
+  //       if (Number(_ds.progDataSource?.dataSourceLimit) === 1) {
+  //         _ds.api_rendered_output = str;
+  //       } else {
+  //         _ds.api_rendered_output = "[" + str + "]";
+  //       }
+  //     }
+
+  //     break;
+  //   }
+
+  //   case "batch": {
+  //     let has_datasource = await calc_batch_loops();
+
+  //     data_arr = _ds.v?.raw_data?.rows || [];
+  //     if (!has_datasource) {
+  //       for (n = 0; n < _ds.v.batch_loops; n++) {
+  //         data_arr.push({});
+  //       }
+  //     }
+  //     _ds.currentRecordId = "dataset";
+  //     for await (let [key, val] of Object.entries(data_arr)) {
+  //       if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
+
+  //       if (!has_datasource) {
+  //         val.value = _ds?.data_feed?.rows?.[_ds.currentRecordId] || {
+  //           value: {},
+  //         };
+  //       }
+
+  //       if (await get_before_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "before_record"
+  //         );
+  //       }
+
+  //       await func.datasource.render_fields_dataset(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         val
+  //       );
+
+  //       if (await get_after_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "after_record"
+  //         );
+  //       }
+  //     }
+
+  //     break;
+  //   }
+
+  //   case "get_data":
+  //     if (await get_before_record_count()) {
+  //       await func.datasource.execute_view_events(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         "before_record"
+  //       );
+  //     }
+
+  //     ret = await db_adapter_module.process_view_dataset(
+  //       SESSION_ID,
+  //       dataSourceSession,
+  //       _ds.v,
+  //       _ds
+  //       // json1
+  //     );
+
+  //     if (await get_after_record_count()) {
+  //       await func.datasource.execute_view_events(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         "after_record"
+  //       );
+  //     }
+
+  //     break;
+
+  //   case "set_data":
+  //     if (
+  //       !prog_obj.progDataSource?.dataSourceType ||
+  //       _ds.progDataSource.dataSourceType !== "table" ||
+  //       !_ds._dataSourceTableId
+  //     ) {
+  //       return func.utils.debug_report(
+  //         SESSION_ID,
+  //         "Data source",
+  //         "Datasource DB Table must be defined for Set Data operation",
+  //         "E"
+  //       );
+  //     }
+
+  //     if (tree_obj.crudMode === "U") {
+  //       _ds.set_mode = "U";
+  //       data_arr = _ds.v?.raw_data?.rows || [];
+  //     }
+
+  //     if (tree_obj.crudMode === "D") {
+  //       _ds.set_mode = "D";
+  //       data_arr = _ds.v?.raw_data?.rows || [];
+  //     }
+
+  //     // initiated with Update but no rows found
+  //     if (
+  //       tree_obj.crudMode === "U" &&
+  //       tree_obj.allowCreate &&
+  //       !_ds.v?.raw_data?.rows?.length
+  //     ) {
+  //       _ds.set_mode = "C";
+  //       data_arr = [{ id: "newRecord", value: {} }];
+  //     }
+
+  //     if (tree_obj.crudMode === "C") {
+  //       _ds.set_mode = "C";
+  //       data_arr = [{ id: "newRecord", value: {} }];
+  //     }
+
+  //     for await (let val of data_arr) {
+  //       _ds.currentRecordId = val.id;
+  //       if (await get_before_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "before_record"
+  //         );
+  //       }
+
+  //       await func.datasource.render_fields_dataset(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         val
+  //       );
+  //       let data_feed_str = JSON.stringify(_ds.data_feed);
+
+  //       if (await get_after_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "after_record"
+  //         );
+  //       }
+
+  //       if (
+  //         _ds.set_mode === "C" ||
+  //         JSON.stringify(_ds.data_feed) !== data_feed_str
+  //       ) {
+  //         const dbMsgP = await func.db.save_data(SESSION_ID, dataSourceSession);
+  //         if (dbMsgP) _ds.currentRecordId = dbMsgP.id;
+  //         _ds.set_mode = "M";
+  //       }
+
+  //       if (_ds.set_mode === "D") {
+  //         const dbMsgP = await func.db.save_data(SESSION_ID, dataSourceSession);
+  //         if (dbMsgP) _ds.currentRecordId = dbMsgP.id;
+  //       }
+  //     }
+  //     // ret = await callback_datasource();
+
+  //     break;
+
+  //   case "component":
+  //     _ds.data_feed = { sort: {}, groupBy: {}, rows: {} };
+
+  //     // _ds.rows_found = 0;
+  //     _ds.rows_processed = 0;
+  //     _ds.viewRangeExp_rows_deleted = 0;
+
+  //     let rows = _ds.v.raw_data?.rows?.length;
+
+  //     _ds.data_feed.rows_changed = [];
+  //     _ds.data_feed.rows_deleted = [];
+  //     _ds.data_feed.rows_added = [];
+
+  //     const row_not_found = async function () {
+  //       _ds.currentRecordId = "newRecord";
+  //       _ds.set_mode = "C";
+  //       _ds.record_not_found = true;
+
+  //       const newRecord = 999999;
+
+  //       if (_.isEmpty(_ds.data_feed.rows[newRecord])) {
+  //         await func.datasource.render_fields_form(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           { id: "newRecord", value: {} },
+  //           null,
+  //           false,
+  //           "newRecord"
+  //         );
+  //       }
+  //       var count = await func.datasource.get_field_init_count(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         "newRecord",
+  //         false
+  //       );
+  //       if (
+  //         count > 0 // was: &&  !args.dataSourceNoP
+  //       ) {
+  //         await func.datasource.execute_field_init_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "form",
+  //           "newRecord"
+  //         );
+  //       }
+  //       // return await callback_datasource();
+  //     };
+  //     if (!rows) {
+  //       await row_not_found();
+  //       break;
+  //     }
+
+  //     _ds.firstRecordId = _ds.v.raw_data.rows[0].id;
+
+  //     const finish_form = async function () {
+  //       // check if locatedRecordId exist in SESSION_OBJ[SESSION_ID].DS_GLB
+  //       if (_ds.locatedRecordId) {
+  //         try {
+  //           const row_idx = func.common.find_ROWID_idx(
+  //             _ds,
+  //             _ds.locatedRecordId
+  //           );
+  //         } catch (error) {
+  //           delete _ds.locatedRecordId;
+  //         }
+  //       }
+
+  //       // if (
+  //       //   _ds.locatedRecordId &&
+  //       //   typeof _ds.data_feed.rows[row_idx] === "undefined"
+  //       // ) {
+  //       //   delete _ds.locatedRecordId;
+  //       // }
+
+  //       db_adapter_module.sort_data(SESSION_ID, dataSourceSession, "form");
+
+  //       _ds.finalRecordId = func.datasource.get_currentRecordId(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         true
+  //       );
+  //       _ds.currentRecordId = _ds.finalRecordId;
+
+  //       // clear db_raw_data to avoid refresh bug when rendering to locate index 0
+
+  //       if (_ds.v.viewRangeExp_deleted) {
+  //         for (let [key, val] of Object.entries(
+  //           _ds.v.viewRangeExp_deleted.reverse()
+  //         )) {
+  //           SESSION_OBJ[SESSION_ID].DS_GLB[
+  //             dataSourceSession
+  //           ].db_raw_data.rows.splice(val, 1);
+  //         }
+  //       }
+
+  //       // return await callback_datasource();
+  //     };
+
+  //     for await (const [key, val] of Object.entries(_ds.v.raw_data.rows)) {
+  //       if (await get_before_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "before_record"
+  //         );
+  //       }
+
+  //       await func.datasource.run_rows_form(
+  //         SESSION_ID,
+  //         dataSourceSession,
+  //         key,
+  //         null,
+  //         null,
+  //         null,
+  //         _ds.pre_init_fields,
+  //         val,
+  //         db_adapter_module
+  //       );
+
+  //       if (await get_after_record_count()) {
+  //         await func.datasource.execute_view_events(
+  //           SESSION_ID,
+  //           dataSourceSession,
+  //           "after_record"
+  //         );
+  //       }
+  //     }
+  //     await finish_form();
+
+  //     break;
+
+  //   default:
+  //     return func.utils.debug_report(
+  //       SESSION_ID,
+  //       "Data source",
+  //       "Program type not defined",
+  //       "E"
+  //     );
+  // }
   ret = await callback_datasource();
   return ret;
 };
@@ -2843,9 +3264,10 @@ func.datasource.render_fields_dataset = async function (
   };
 
   if (!_ds.data_feed) {
-    _ds.data_feed = { rows: {} };
+    _ds.data_feed = { rows: [] };
   }
-  let data_feed = (_ds.data_feed.rows[_ds.currentRecordId] = {});
+  let data_feed = { _ROWID: _ds.currentRecordId };
+
   _ds.dataset_alias = {};
 
   for await (const val of _progFields) {
@@ -2884,6 +3306,7 @@ func.datasource.render_fields_dataset = async function (
       func.utils.debug_report(SESSION_ID, "Datasource", err, "E", null, _ds);
     }
   }
+  _ds.data_feed.rows.push(data_feed);
 };
 
 func.datasource.run_events_functions = async function (
@@ -2993,7 +3416,17 @@ func.datasource.render_fields_form = async function (
     );
   };
 
-  if (!_ds.data_feed.rows[data.id]) _ds.data_feed.rows[data.id] = {};
+  // if (!_ds.data_feed.rows[row_idx])
+  //   _ds.data_feed.rows[row_idx] = { _ROWID: data.id };
+
+  let row_idx;
+  try {
+    row_idx = func.common.find_ROWID_idx(_ds, data.id);
+  } catch (error) {
+    _ds.data_feed.rows.push({ _ROWID: data.id });
+    row_idx = func.common.find_ROWID_idx(_ds, data.id);
+  }
+
   _ds.dataset_alias = {};
 
   for await (const val of _progFields) {
@@ -3003,27 +3436,39 @@ func.datasource.render_fields_form = async function (
       if (val.data.type === "virtual" || data.id === "newRecord") {
         if (glb.PROTECTED_VARS.includes(fieldId)) {
           switch (fieldId) {
-            case "_ROW_NO": {
+            case "_ROWNO": {
               let row_no =
-                Object.keys(_ds?.data_feed?.rows).indexOf(data.id) || 0;
-              _ds.data_feed.rows[data.id][fieldId] = await get_value(
-                fieldId,
-                row_no
-              );
+                // Object.keys(_ds?.data_feed?.rows).indexOf(data.id) || 0;
+                // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+                //   fieldId,
+                //   row_no
+                // );
+                (_ds.data_feed.rows[row_idx][fieldId] = await get_value(
+                  fieldId,
+                  row_idx
+                ));
               continue;
             }
-            case "_ROW_ID": {
-              _ds.data_feed.rows[data.id][fieldId] = await get_value(
+            case "_ROWID": {
+              _ds.data_feed.rows[row_idx][fieldId] = await get_value(
                 fieldId,
                 data.id
               );
+              // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+              //   fieldId,
+              //   data.id
+              // );
               continue;
             }
-            case "_ROW_DOC": {
-              _ds.data_feed.rows[data.id][fieldId] = await get_value(
+            case "_ROWDOC": {
+              _ds.data_feed.rows[row_idx][fieldId] = await get_value(
                 fieldId,
                 data
               );
+              // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+              //   fieldId,
+              //   data
+              // );
               continue;
             }
           }
@@ -3038,28 +3483,40 @@ func.datasource.render_fields_form = async function (
             "update",
             data.id
           );
-          _ds.data_feed.rows[data.id][fieldId] = await get_value(
+          _ds.data_feed.rows[row_idx][fieldId] = await get_value(
             fieldId,
             ret.result
           );
+          // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+          //   fieldId,
+          //   ret.result
+          // );
 
           continue;
         }
 
-        _ds.data_feed.rows[data.id][fieldId] = await get_value(
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
           fieldId,
           val.props?.fieldValue
         );
+        // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+        //   fieldId,
+        //   val.props?.fieldValue
+        // );
         continue;
       }
       if (val.data.type === "table" || val.data.type === "datasource") {
         if (typeof data.value[fieldId] === "undefined") {
           throw "field do not exist in data: " + fieldId;
         }
-        _ds.data_feed.rows[data.id][fieldId] = await get_value(
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
           fieldId,
           data.value[fieldId]
         );
+        // _ds.data_feed.rows[data.id][fieldId] = await get_value(
+        //   fieldId,
+        //   data.value[fieldId]
+        // );
       }
     } catch (err) {
       func.utils.debug_report(SESSION_ID, "Datasource", err, "E", null, _ds);
@@ -3067,6 +3524,143 @@ func.datasource.render_fields_form = async function (
   }
 };
 
+// func.datasource.run_rows_form = async function (
+//   SESSION_ID,
+//   dataSourceSession,
+//   rowIdxP,
+//   NA_onDemandP,
+//   NA_callbackP,
+//   NA_oninit_triggers_to_runP,
+//   pre_init_fieldsP,
+//   data,
+//   db_adapter_module
+// ) {
+//   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
+//   if (!_ds) return;
+//   // var v = _ds.v;
+
+//   var val = _ds.data_feed.rows[rowIdxP];
+
+//   var idx;
+
+//   try {
+//     if (typeof val !== "undefined") {
+//       if (val.id) idx = val.id;
+//       else if (val.value) idx = val.value._id;
+//       else idx = val;
+//     } else {
+//       idx = "newRecord";
+//     }
+//   } catch (e) {
+//     console.error(e);
+//   }
+//   // var sort_index = rowIdxP - _ds.viewRangeExp_rows_deleted;
+//   //
+//   const add_row = async function () {
+//     var old_row_data;
+
+//     _ds.data_feed.rows[idx] = {};
+//     // _ds.data_feed.rows[idx].arrIndex = sort_index; // removed 022623 needs other solution
+
+//     const form_continue = async function (render_fields) {
+//       _ds.rows_processed++;
+//       // const sort_form = async function () {
+//       //   await db_adapter_module.add_sort(
+//       //     SESSION_ID,
+//       //     dataSourceSession,
+//       //     "form",
+//       //     _ds.progDataSource.dataSourceSortScript,
+//       //     idx,
+//       //     sort_index
+//       //   );
+//       //   await db_adapter_module.add_GroupBy(
+//       //     SESSION_ID,
+//       //     dataSourceSession,
+//       //     "form",
+//       //     _ds.progDataSource.dataSourceGroupByScript,
+//       //     idx,
+//       //     sort_index
+//       //   );
+//       //   // _ds.rows_found++;
+//       // };
+//       const delete_row = async function () {
+//         if (_ds) {
+//           delete _ds.data_feed.rows[idx];
+
+//           if (!_ds.v.viewRangeExp_deleted) _ds.v.viewRangeExp_deleted = [];
+//           _ds.v.viewRangeExp_deleted.push(rowIdxP);
+//         }
+//         // _ds.rows_found--;
+//         _ds.viewRangeExp_rows_deleted++;
+//       };
+//       if (_ds.progDataSource?.dataSourceFiltersScript) {
+//         var res = await func.datasource.validate_viewRange(
+//           SESSION_ID,
+//           _ds.progDataSource.dataSourceFiltersScript,
+//           dataSourceSession,
+//           idx,
+//           "form"
+//         );
+//         if (
+//           res === false ||
+//           res === 0 ||
+//           typeof res === "undefined" ||
+//           res === null
+//         ) {
+//           await delete_row();
+//         }
+//       }
+//       // await sort_form();
+
+//       if (_ds.progDataSource?.dataSourceLocateScript) {
+//         var res = func.datasource.validate_viewLocate(
+//           SESSION_ID,
+//           _ds.progDataSource.dataSourceLocateScript,
+//           dataSourceSession,
+//           idx,
+//           "form"
+//         );
+//         if (res) {
+//           _ds.locatedRecordId = idx;
+//         }
+//       }
+//       if (_ds.progDataSource?.dataSourceFiltersScript) {
+//         return;
+//       }
+//     };
+//     _ds.currentRecordId = idx; // set temporary to allow expression decoder work
+
+//     await func.datasource.render_fields_form(
+//       SESSION_ID,
+//       dataSourceSession,
+//       data,
+//       null,
+//       true,
+//       idx,
+//       true,
+//       pre_init_fieldsP
+//     );
+//     const init_count = await func.datasource.get_field_init_count(
+//       SESSION_ID,
+//       dataSourceSession,
+//       idx,
+//       false,
+//       _ds.oninit_triggers_to_run
+//     );
+//     if (init_count > 0) {
+//       await func.datasource.execute_field_init_events(
+//         SESSION_ID,
+//         dataSourceSession,
+//         "form",
+//         idx
+//       );
+//     }
+//     await form_continue();
+//   };
+
+//   await add_row();
+// };
+
 func.datasource.run_rows_form = async function (
   SESSION_ID,
   dataSourceSession,
@@ -3082,127 +3676,123 @@ func.datasource.run_rows_form = async function (
   if (!_ds) return;
   // var v = _ds.v;
 
-  var val = _ds.v.raw_data.rows[rowIdxP];
+  var val = _ds.data_feed.rows[rowIdxP];
 
   var idx;
 
   try {
     if (typeof val !== "undefined") {
-      if (val.id) idx = val.id;
-      else if (val.value) idx = val.value._id;
-      else idx = val;
+      idx = _ROWID;
     } else {
-      idx = "newRecord";
+      const newRecord = 999999;
+      val = _ds.data_feed.rows[newRecord] = { _ROWID: newRecord };
+      idx = newRecord;
     }
   } catch (e) {
     console.error(e);
   }
-  var sort_index = rowIdxP - _ds.viewRangeExp_rows_deleted;
+  // var sort_index = rowIdxP - _ds.viewRangeExp_rows_deleted;
   //
-  const add_row = async function () {
-    var old_row_data;
-
-    _ds.data_feed.rows[idx] = {};
-    // _ds.data_feed.rows[idx].arrIndex = sort_index; // removed 022623 needs other solution
-
-    const form_continue = async function (render_fields) {
-      _ds.rows_processed++;
-      const sort_form = async function () {
-        await db_adapter_module.add_sort(
-          SESSION_ID,
-          dataSourceSession,
-          "form",
-          _ds.progDataSource.dataSourceSortScript,
-          idx,
-          sort_index
-        );
-        await db_adapter_module.add_GroupBy(
-          SESSION_ID,
-          dataSourceSession,
-          "form",
-          _ds.progDataSource.dataSourceGroupByScript,
-          idx,
-          sort_index
-        );
-        // _ds.rows_found++;
-      };
-      const delete_row = async function () {
-        if (_ds) {
-          delete _ds.data_feed.rows[idx];
 
-          if (!_ds.v.viewRangeExp_deleted) _ds.v.viewRangeExp_deleted = [];
-          _ds.v.viewRangeExp_deleted.push(rowIdxP);
-        }
-        // _ds.rows_found--;
-        _ds.viewRangeExp_rows_deleted++;
-      };
-      if (_ds.progDataSource?.dataSourceFiltersScript) {
-        var res = await func.datasource.validate_viewRange(
-          SESSION_ID,
-          _ds.progDataSource.dataSourceFiltersScript,
-          dataSourceSession,
-          idx,
-          "form"
-        );
-        if (
-          res === false ||
-          res === 0 ||
-          typeof res === "undefined" ||
-          res === null
-        ) {
-          await delete_row();
-        }
-      }
-      await sort_form();
+  // _ds.data_feed.rows[idx] = { _ROWID: val._ROWID };
+  // _ds.data_feed.rows[idx].arrIndex = sort_index; // removed 022623 needs other solution
+
+  // const form_continue = async function (render_fields) {
+  //   _ds.rows_processed++;
+  //   // const sort_form = async function () {
+  //   //   await db_adapter_module.add_sort(
+  //   //     SESSION_ID,
+  //   //     dataSourceSession,
+  //   //     "form",
+  //   //     _ds.progDataSource.dataSourceSortScript,
+  //   //     idx,
+  //   //     sort_index
+  //   //   );
+  //   //   await db_adapter_module.add_GroupBy(
+  //   //     SESSION_ID,
+  //   //     dataSourceSession,
+  //   //     "form",
+  //   //     _ds.progDataSource.dataSourceGroupByScript,
+  //   //     idx,
+  //   //     sort_index
+  //   //   );
+  //   //   // _ds.rows_found++;
+  //   // };
+  //   const delete_row = async function () {
+  //     if (_ds) {
+  //       delete _ds.data_feed.rows[idx];
+
+  //       if (!_ds.v.viewRangeExp_deleted) _ds.v.viewRangeExp_deleted = [];
+  //       _ds.v.viewRangeExp_deleted.push(rowIdxP);
+  //     }
+  //     // _ds.rows_found--;
+  //     _ds.viewRangeExp_rows_deleted++;
+  //   };
+  //   if (_ds.progDataSource?.dataSourceFiltersScript) {
+  //     var res = await func.datasource.validate_viewRange(
+  //       SESSION_ID,
+  //       _ds.progDataSource.dataSourceFiltersScript,
+  //       dataSourceSession,
+  //       idx,
+  //       "form"
+  //     );
+  //     if (
+  //       res === false ||
+  //       res === 0 ||
+  //       typeof res === "undefined" ||
+  //       res === null
+  //     ) {
+  //       await delete_row();
+  //     }
+  //   }
+  //   // await sort_form();
 
-      if (_ds.progDataSource?.dataSourceLocateScript) {
-        var res = func.datasource.validate_viewLocate(
-          SESSION_ID,
-          _ds.progDataSource.dataSourceLocateScript,
-          dataSourceSession,
-          idx,
-          "form"
-        );
-        if (res) {
-          _ds.locatedRecordId = idx;
-        }
-      }
-      if (_ds.progDataSource?.dataSourceFiltersScript) {
-        return;
-      }
-    };
-    _ds.currentRecordId = idx; // set temporary to allow expression decoder work
+  //   if (_ds.progDataSource?.dataSourceLocateScript) {
+  //     var res = func.datasource.validate_viewLocate(
+  //       SESSION_ID,
+  //       _ds.progDataSource.dataSourceLocateScript,
+  //       dataSourceSession,
+  //       idx,
+  //       "form"
+  //     );
+  //     if (res) {
+  //       _ds.locatedRecordId = idx;
+  //     }
+  //   }
+  //   if (_ds.progDataSource?.dataSourceFiltersScript) {
+  //     return;
+  //   }
+  // };
+  _ds.currentRecordId = val._ROWID; // set temporary to allow expression decoder work
 
-    await func.datasource.render_fields_form(
-      SESSION_ID,
-      dataSourceSession,
-      data,
-      null,
-      true,
-      idx,
-      true,
-      pre_init_fieldsP
-    );
-    const init_count = await func.datasource.get_field_init_count(
+  await func.datasource.render_fields_form(
+    SESSION_ID,
+    dataSourceSession,
+    data
+    // null,
+    // true,
+    // idx,
+    // true,
+    // pre_init_fieldsP
+  );
+  const init_count = await func.datasource.get_field_init_count(
+    SESSION_ID,
+    dataSourceSession,
+    idx,
+    false,
+    _ds.oninit_triggers_to_run
+  );
+  if (init_count > 0) {
+    await func.datasource.execute_field_init_events(
       SESSION_ID,
       dataSourceSession,
-      idx,
-      false,
-      _ds.oninit_triggers_to_run
+      "form",
+      idx
     );
-    if (init_count > 0) {
-      await func.datasource.execute_field_init_events(
-        SESSION_ID,
-        dataSourceSession,
-        "form",
-        idx
-      );
-    }
-    await form_continue();
-  };
-
-  await add_row();
+  }
+  // await form_continue();
 };
+
 func.datasource.execute_field_init_events = async function (
   SESSION_ID,
   dataSourceSession,
@@ -3809,9 +4399,9 @@ func.datasource.update = async function (
         continue;
       }
 
-      for (const [row_id, fields_data] of Object.entries(row_data)) {
+      for (const [record_id, fields_data] of Object.entries(row_data)) {
         for (const [field_id, value] of Object.entries(fields_data)) {
-          if (row_id === "datasource_main") {
+          if (record_id === "datasource_main") {
             // _ds[field_id] = value;
             _.set(_ds, field_id, value);
             continue;
@@ -3824,7 +4414,14 @@ func.datasource.update = async function (
               continue;
             }
 
-            _ds.data_feed.rows[row_id][field_id] = value;
+            try {
+              const row_idx = func.common.find_ROWID_idx(_ds, record_id);
+              _ds.data_feed.rows[row_idx][field_id] = value;
+            } catch (err) {
+              console.error(err);
+            }
+
+            // _ds.data_feed.rows[record_id][field_id] = value;
 
             if (!fields_changes.includes(field_id)) {
               fields_changes.push(field_id);
@@ -3833,14 +4430,14 @@ func.datasource.update = async function (
               datasource_changed.push(dataSource);
             }
           } else if (fields_data === "set") {
-            _ds.currentRecordId = row_id;
+            _ds.currentRecordId = record_id;
           }
         }
         if (!_ds.data_feed.rows_changed) {
           _ds.data_feed.rows_changed = [];
         }
-        if (!_ds.data_feed.rows_changed.includes(row_id))
-          _ds.data_feed.rows_changed.push(row_id);
+        if (!_ds.data_feed.rows_changed.includes(record_id))
+          _ds.data_feed.rows_changed.push(record_id);
       }
 
       if (!from_worker) {
@@ -3916,11 +4513,13 @@ func.datasource.callback = function (
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dsSessionP];
 
+  const dataset = 0;
+
   if (_ds.PARAM_OUT_INFO) {
     // write log for out params
     for (const [key, val] of Object.entries(_ds.PARAM_OUT_INFO)) {
       if (
-        typeof _ds?.data_feed?.rows?.["dataset"]?.[val.fieldId] === "undefined"
+        typeof _ds?.data_feed?.rows?.[dataset]?.[val.fieldId] === "undefined"
       ) {
         // func.utils.debug.log(SESSION_ID, key, val);
         func.utils.alerts.invoke(
@@ -3932,7 +4531,7 @@ func.datasource.callback = function (
         );
         break;
       }
-      val.result = _ds.data_feed.rows["dataset"][val.fieldId];
+      val.result = _ds.data_feed.rows[dataset][val.fieldId];
     }
   }
 
@@ -4392,33 +4991,40 @@ func.datasource.get_value = async function (
   }
 
   if (!org_dsSessionP && recordId) {
-    // if (typeof _ds.data_feed?.rows?.[recordId]?.[_field_id] !== "undefined") {
-    if (
-      Object.keys(_ds.data_feed?.rows?.[recordId] || {})?.includes(_field_id)
-    ) {
-      return await return_value(
-        _field_id,
-        _ds.data_feed.rows[recordId][_field_id]
-      );
+    try {
+      const row_idx = func.common.find_ROWID_idx(_ds, recordId);
+      // if (typeof _ds.data_feed?.rows?.[recordId]?.[_field_id] !== "undefined") {
+      if (
+        Object.keys(_ds.data_feed?.rows?.[row_idx] || {})?.includes(_field_id)
+      ) {
+        return await return_value(
+          _field_id,
+          _ds.data_feed.rows[row_idx][_field_id]
+        );
+      }
+      // if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
+      if (Object.keys(_ds?.dynamic_fields || {})?.includes(_field_id)) {
+        return await return_dynamic_value(
+          _field_id,
+          _ds.dynamic_fields[_field_id]
+        );
+      }
+    } catch (err) {
+      console.error(err);
     }
-    // if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
-    if (Object.keys(_ds?.dynamic_fields || {})?.includes(_field_id)) {
-      return await return_dynamic_value(
+  }
+
+  try {
+    const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+
+    if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== "undefined") {
+      return await return_value(
         _field_id,
-        _ds.dynamic_fields[_field_id]
+        _ds.data_feed.rows[row_idx][_field_id]
       );
     }
-  }
+  } catch (error) {}
 
-  if (
-    typeof _ds.data_feed?.rows?.[_ds.currentRecordId]?.[_field_id] !==
-    "undefined"
-  ) {
-    return await return_value(
-      _field_id,
-      _ds.data_feed.rows[_ds.currentRecordId][_field_id]
-    );
-  }
   if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
     return await return_dynamic_value(_field_id, _ds.dynamic_fields[_field_id]);
   }
@@ -5203,7 +5809,7 @@ func.utils.clean_returned_datasource = function (SESSION_ID, DS) {
   // }
   delete obj.pre_init_fields;
   delete obj.oninit_triggers_to_run;
-  delete obj.raw_data;
+  // delete obj.raw_data;
 
   delete obj.debug;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-worker-bundle-min",
-  "version": "1.3.816",
+  "version": "1.3.818",
   "description": "xuda framework min",
   "main": "index.js",
   "scripts": {