@sankhyalabs/sankhyablocks 8.15.0-dev.6 → 8.15.0-dev.60

package/dist/cjs/{dataunit-fetcher-bd4c52da.js → pesquisa-fetcher-cb768be1.js}

@@ -1,12 +1,266 @@
 'use strict';
 
 const core = require('@sankhyalabs/core');
-const DataFetcher = require('./DataFetcher-ba94ed5b.js');
+const formConfigFetcher = require('./form-config-fetcher-3c4daeb5.js');
 const constants = require('@sankhyalabs/ezui/dist/collection/utils/constants');
 const UnitMetadata = require('@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata');
-const PreloadManager = require('./PreloadManager-84466da6.js');
-const ResourceIDUtils = require('./ResourceIDUtils-5ff86aa7.js');
 const utils = require('@sankhyalabs/ezui/dist/collection/components/ez-grid/utils');
+const SortingUtils = require('@sankhyalabs/core/dist/utils/SortingUtils');
+const ResourceIDUtils = require('./ResourceIDUtils-5ff86aa7.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const SortingUtils__default = /*#__PURE__*/_interopDefaultLegacy(SortingUtils);
+
+class ArrayRepository {
+  constructor(equalsFunction) {
+    this._list = [];
+    this._equalsFunction = equalsFunction;
+  }
+  async load(filterFunction, sortingFunction, offset, limit) {
+    let result = [].concat(this._list);
+    if (filterFunction != undefined) {
+      result = this._list.filter(item => filterFunction(item));
+    }
+    if (sortingFunction != undefined) {
+      result = result.sort(sortingFunction);
+    }
+    const count = result.length;
+    if (limit != undefined) {
+      const start = offset || 0;
+      const end = limit ? start + limit : result.length;
+      result = result.slice(start, end);
+    }
+    return Promise.resolve({ result, count });
+  }
+  async distict(itemProcessor) {
+    const processedItems = [];
+    let hasEmpty = false;
+    for (const item of this._list) {
+      const processedItem = itemProcessor(item);
+      if (processedItem == undefined) {
+        continue;
+      }
+      if (processedItem.value == undefined) {
+        hasEmpty = true;
+        continue;
+      }
+      processedItems.push(processedItem);
+    }
+    if (hasEmpty) {
+      processedItems.push({ key: "", value: null });
+    }
+    return Promise.resolve(new Map(processedItems.map(item => [item.key, item.value])));
+  }
+  async push(items) {
+    this._list.push(...items);
+  }
+  async clear() {
+    this._list = [];
+  }
+  async delete(items) {
+    this._list = this._list.filter(item => {
+      for (const removed of items) {
+        if (this._equalsFunction(item, removed)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  async update(items) {
+    this._list = this._list.map(existingItem => {
+      const newItem = items.find(newItem => this._equalsFunction(existingItem, newItem));
+      return newItem == undefined ? existingItem : newItem;
+    });
+  }
+  async insert(itemReference, items) {
+    const itemPosition = this._list.indexOf(itemReference);
+    if (itemPosition == -1) {
+      this._list.push(...items);
+      return;
+    }
+    this._list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
+  }
+  isOperating() {
+    return true;
+  }
+  async isEmpty() {
+    return Promise.resolve(this._list.length === 0);
+  }
+  async count() {
+    return Promise.resolve(this._list.length);
+  }
+  getFromCache() {
+    return core.ObjectUtils.copy(this._list);
+  }
+}
+
+class PreloadManager {
+  static setLoadingStatus(dataUnit, loadingInProgress) {
+    this._loadingStatus.set(dataUnit.name, loadingInProgress);
+  }
+  static isCacheEnabled(_dataUnit) {
+    return true;
+  }
+  static cacheRecords(dataUnit, records, resetDatabase, loadingInProgress) {
+    PreloadManager.setLoadingStatus(dataUnit, loadingInProgress);
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      this.getRepository(dataUnit).push(records);
+    }
+    else {
+      if (resetDatabase) {
+        this._repositories.delete(dataUnit.name);
+      }
+    }
+  }
+  static getSortingFunction(dataUnit, sorting) {
+    return SortingUtils__default['default'].getSortingFunction(dataUnit, sorting);
+  }
+  static async getDistinct(dataUnit, fieldName) {
+    if (!PreloadManager.isCacheEnabled(dataUnit)) {
+      return Promise.resolve(utils.ColumnFilterManager.compileDistinct(fieldName, dataUnit));
+    }
+    let filterFunction;
+    const request = dataUnit.getLastLoadRequest();
+    if (request != undefined) {
+      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, fieldName);
+      filterFunction = utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    }
+    return new Promise((accept, reject) => {
+      PreloadManager.getRepository(dataUnit).distict(record => {
+        if (filterFunction != undefined && !filterFunction(record)) {
+          return undefined;
+        }
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return { key: null, value: null };
+        }
+        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        return { key: dataUnit.getFormattedValue(fieldName, fieldValue), value };
+      })
+        .then(result => {
+        if (result == undefined) {
+          accept(undefined);
+          return;
+        }
+        accept(Array.from(result.entries()).map(([label, value]) => ({ label, value, check: true })));
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+  static async loadData(dataUnit, request, loadFromServer) {
+    try {
+      if (PreloadManager.isCacheEnabled(dataUnit)) {
+        const useCache = [
+          "EZ_GRID_LOADING_SOURCE",
+          core.DataUnit.CHANGING_PAGE_LOADING_SOURCE,
+          core.DataUnit.ALL_RECORDS_SELECTION_SOURCE
+        ].includes(request.source);
+        if (useCache) {
+          const isCacheEmpty = await PreloadManager.getRepository(dataUnit).isEmpty();
+          if (!isCacheEmpty) {
+            return PreloadManager.loadFromCache(dataUnit, request);
+          }
+        }
+        //Como não vamos aproveitar o cache, ele precisa ser limpo.
+        PreloadManager.getRepository(dataUnit).clear().catch(() => { });
+      }
+      return loadFromServer(dataUnit, request);
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  static insertRecords(dataUnit, reference, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).insert(reference, records);
+    }
+  }
+  static updateRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).update(records);
+    }
+  }
+  static removeRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).delete(records);
+    }
+  }
+  static async countRecords(dataUnit) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      return PreloadManager.getRepository(dataUnit).count();
+    }
+    return Promise.resolve(0);
+  }
+  static getRepository(dataUnit) {
+    const name = dataUnit.name;
+    if (!PreloadManager._repositories.has(name)) {
+      PreloadManager._repositories.set(name, new ArrayRepository((recordA, recordB) => recordA.__record__id__ === recordB.__record__id__));
+    }
+    return PreloadManager._repositories.get(name);
+  }
+  static async loadFromCache(dataUnit, request) {
+    return new Promise((accept, reject) => {
+      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, "");
+      const { limit, offset, sort } = request;
+      PreloadManager.getRepository(dataUnit)
+        .load(utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values())), PreloadManager.getSortingFunction(dataUnit, sort), offset, limit)
+        .then(loadResult => {
+        const stillLoading = PreloadManager._loadingStatus.get(dataUnit.name);
+        const { count, result: records } = loadResult;
+        const firstRecord = count == 0 ? 0 : offset + 1;
+        const lastRecord = offset + Math.min(records.length, limit);
+        const currentPage = offset / limit;
+        const paginationInfo = {
+          count, currentPage, firstRecord, lastRecord,
+          hasMore: stillLoading || (lastRecord < count),
+          total: stillLoading ? undefined : count
+        };
+        accept({ records, paginationInfo });
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+  static getCachedRecords(dataUnit) {
+    return PreloadManager.getRepository(dataUnit).getFromCache();
+  }
+}
+PreloadManager._repositories = new Map();
+PreloadManager._loadingStatus = new Map();
+
+function applyFilter(records, dataUnit, filters) {
+  const columnFilters = utils.ColumnFilterManager.getColumnFilters(filters, "");
+  if (!(columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.size)) {
+    return records;
+  }
+  const filterFunction = utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+  if (filterFunction == undefined) {
+    return records;
+  }
+  return records.filter(filterFunction);
+}
+function applySorting(records, dataUnit, sorting) {
+  if (sorting == undefined || sorting.length == 0) {
+    return records;
+  }
+  const sortingFunction = PreloadManager.getSortingFunction(dataUnit, sorting);
+  if (sortingFunction == undefined) {
+    return records;
+  }
+  return records.sort(sortingFunction);
+}
+function buildPaginationInfo(records, offset = 0, limit = 0) {
+  const lastRecord = Math.min(offset + limit, records === null || records === void 0 ? void 0 : records.length);
+  return {
+    currentPage: limit === 0 ? 0 : Math.ceil(offset / limit),
+    firstRecord: offset,
+    lastRecord: lastRecord,
+    total: records === null || records === void 0 ? void 0 : records.length,
+    hasMore: !!((records === null || records === void 0 ? void 0 : records.length) - lastRecord),
+  };
+}
 
 class InMemoryLoader {
   constructor(metadata, records) {
@@ -23,6 +277,10 @@ class InMemoryLoader {
     if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
       this._initialRecords = this.dataUnit.records;
     }
+    const addedRecords = this.dataUnit.getAddedRecords();
+    if (addedRecords) {
+      return [...this._initialRecords, ...addedRecords];
+    }
     return this._initialRecords;
   }
   get dataUnit() {
@@ -65,7 +323,7 @@ class InMemoryLoader {
     this._initialRecords = newRecords;
     if (this._dataUnit) {
       //Isso força o refresh internamente no datunit
-      this._dataUnit.gotoPage(0);
+      this._dataUnit.loadData();
     }
   }
   get metadata() {
@@ -81,30 +339,9 @@ class InMemoryLoader {
     return core.StringUtils.generateUUID();
   }
   inMemoryLoader(dataUnit, request, recordsIn) {
-    let records = this.applyFilter(recordsIn, dataUnit, request.filters);
-    records = this.applySorting(records, dataUnit, request.sort);
-    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(request, records) });
-  }
-  applyFilter(records, dataUnit, filters) {
-    const columnFilters = utils.ColumnFilterManager.getColumnFilters(filters, "");
-    if (columnFilters == undefined || columnFilters.size == 0) {
-      return records;
-    }
-    const filterFunciton = utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
-    if (filterFunciton == undefined) {
-      return records;
-    }
-    return records.filter(filterFunciton);
-  }
-  applySorting(records, dataUnit, sorting) {
-    if (sorting == undefined || sorting.length == 0) {
-      return records;
-    }
-    const sortingFunction = PreloadManager.PreloadManager.getSortingFunction(dataUnit, sorting);
-    if (sortingFunction == undefined) {
-      return records;
-    }
-    return records.sort(sortingFunction);
+    let records = applyFilter(recordsIn, dataUnit, request.filters);
+    records = applySorting(records, dataUnit, request.sort);
+    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(records, request.offset, request.limit) });
   }
   metadaLoader() {
     return Promise.resolve(this._metadata);
@@ -137,50 +374,45 @@ class InMemoryLoader {
   }
 }
 InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";
-function buildPaginationInfo({ offset, limit }, records) {
-  if (offset === undefined || limit === undefined) {
-    return undefined;
-  }
-  const lastRecord = Math.min(offset + limit, records.length);
-  return {
-    currentPage: Math.ceil(offset / limit),
-    firstRecord: offset,
-    lastRecord: lastRecord,
-    total: records.length,
-    hasMore: !!(records.length - lastRecord),
-  };
-}
 
 class DatasetStrategy {
   canSlice() {
     return false;
   }
+  processSortingSide(request, dataUnit, serverSideFilters) {
+    var _a;
+    const localSorting = [];
+    const serverSorting = [];
+    if (request.sort != undefined) {
+      if (serverSideFilters.length === 0) {
+        return { localSorting: request.sort, serverSorting: [] };
+      }
+      for (const sort of request.sort) {
+        const descriptor = dataUnit.getField(sort.field);
+        const local = ((_a = descriptor === null || descriptor === void 0 ? void 0 : descriptor.properties) === null || _a === void 0 ? void 0 : _a.calculated) === "true" || (descriptor === null || descriptor === void 0 ? void 0 : descriptor.userInterface) === core.UserInterface.LONGTEXT;
+        if (local) {
+          localSorting.push(sort);
+        }
+        else {
+          serverSorting.push(sort);
+        }
+      }
+    }
+    return { localSorting, serverSorting };
+  }
   async load(dataUnit, request, loadingInfo) {
+    var _a, _b;
     if (dataUnit.metadata == undefined) {
       return Promise.resolve({ records: [], loadingInfo });
     }
     try {
-      const localSorting = [];
-      const serverSorting = [];
-      if (request.sort != undefined) {
-        for (const sort of request.sort) {
-          const descriptor = dataUnit.getField(sort.field);
-          const local = descriptor != undefined
-            && descriptor.properties != undefined
-            && descriptor.properties.calculated === "true";
-          if (local) {
-            localSorting.push(sort);
-          }
-          else {
-            serverSorting.push(sort);
-          }
-        }
-      }
+      const serverSideFilters = (_b = (_a = request.filters) === null || _a === void 0 ? void 0 : _a.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"))) !== null && _b !== void 0 ? _b : [];
+      const { localSorting, serverSorting } = this.processSortingSide(request, dataUnit, serverSideFilters);
       const fields = this.getFieldsList(dataUnit);
       const serviceName = "DatasetSP.loadRecords";
-      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, serverSorting);
+      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, serverSorting, serverSideFilters);
       const params = loadingInfo.quiet ? { urlParams: { quietMode: "true" } } : undefined;
-      const { result: responseRecords, pagerID: pagerId } = await DataFetcher.DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
+      const { result: responseRecords, pagerID: pagerId } = await formConfigFetcher.DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
       const records = this.processRecords(dataUnit, fields, responseRecords);
       const loadingInProgress = pagerId != undefined;
       const count = loadingInfo.count + records.length;
@@ -222,7 +454,7 @@ class DatasetStrategy {
     }
     return [descriptor.name, descriptionField];
   }
-  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, sorting) {
+  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, sorting, serverSideFilters) {
     const dataSetID = dataUnit.dataUnitId;
     const dataUnitName = dataUnit.name;
     const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
@@ -241,7 +473,7 @@ class DatasetStrategy {
         tryJoinedFields: true,
         parallelLoader: useParallelLoader,
         crudListener: `br.com.sankhya.bff.${this.getModuleName()}.BFFDataUnitDatasetAdapter`,
-        txProperties: this.getTxProperties(dataUnitName, request, sorting),
+        txProperties: this.getTxProperties(dataUnit, request, sorting, serverSideFilters),
         useDefaultRowsLimit: false
       }
     };
@@ -252,12 +484,10 @@ class DatasetStrategy {
     const moduleName = app.getModuleName();
     return moduleName.replace("-bff", "");
   }
-  getTxProperties(dataUnitName, request, sorting) {
-    var _a, _b;
+  getTxProperties(dataUnit, request, sorting, serverSideFilters) {
     const txProperties = {
-      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnitName
+      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnit.name
     };
-    const serverSideFilters = (_b = (_a = request.filters) === null || _a === void 0 ? void 0 : _a.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"))) !== null && _b !== void 0 ? _b : [];
     if (serverSideFilters.length !== 0) {
       txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
     }
@@ -267,6 +497,13 @@ class DatasetStrategy {
     if (request.parentRecordId != undefined) {
       txProperties["__DATA_UNIT_ADAPTER__[parentRecordId]"] = request.parentRecordId;
     }
+    const loaderProps = dataUnit.getGlobalLoaderProps();
+    if (loaderProps == undefined || loaderProps.size === 0) {
+      return txProperties;
+    }
+    Array.from(loaderProps.entries()).forEach(([name, value]) => {
+      txProperties[name] = value;
+    });
     return txProperties;
   }
   processRecords(dataUnit, fields, responseRecords) {
@@ -330,12 +567,15 @@ class DataUnitDataLoader {
   static async loadData(dataUnit, request) {
     return new Promise((resolve, reject) => {
       DataUnitDataLoader.debounce(dataUnit, () => {
-        PreloadManager.PreloadManager.loadData(dataUnit, request, this.loadFromServer)
+        PreloadManager.loadData(dataUnit, request, this.loadFromServer)
           .then(resp => resolve(resp))
           .catch(reason => reject(reason));
       });
     });
   }
+  static getCachedRecords(dataUnit) {
+    return PreloadManager.getCachedRecords(dataUnit);
+  }
   static async loadFromServer(dataUnit, request, loadingInfo) {
     try {
       //Registramos a request com as informações de carga para determinarmos a última.
@@ -367,8 +607,8 @@ class DataUnitDataLoader {
       return Promise.resolve(undefined);
     }
     const recreateCache = !dataLoader.canSlice() || responseLoadingInfo.count === 0;
-    PreloadManager.PreloadManager.cacheRecords(dataUnit, records, recreateCache, responseLoadingInfo.loadingInProgress);
-    if (PreloadManager.PreloadManager.isCacheEnabled(dataUnit) && responseLoadingInfo.loadingInProgress) {
+    PreloadManager.cacheRecords(dataUnit, records, recreateCache, responseLoadingInfo.loadingInProgress);
+    if (PreloadManager.isCacheEnabled(dataUnit) && responseLoadingInfo.loadingInProgress) {
       const newRequest = Object.assign(Object.assign({}, request), { offset: responseLoadingInfo.count });
       const newLoadingInfo = Object.assign(Object.assign({}, responseLoadingInfo), { pageNumber: (responseLoadingInfo.pageNumber || 0) + 1, quiet: true });
       this.callLoader(dataUnit, newRequest, newLoadingInfo, dataLoader)
@@ -378,7 +618,7 @@ class DataUnitDataLoader {
     return Promise.resolve(result);
   }
   static afterLoadingPage(dataUnit, loadingInfo) {
-    PreloadManager.PreloadManager.setLoadingStatus(dataUnit, loadingInfo.loadingInProgress);
+    PreloadManager.setLoadingStatus(dataUnit, loadingInfo.loadingInProgress);
     const dataUnitPagination = dataUnit.getPaginationInfo();
     if (dataUnitPagination == undefined) {
       return;
@@ -450,7 +690,7 @@ class DataUnitFetcher {
     this.buldTemplates();
   }
   buldTemplates() {
-    this.templateByQuery.set("fetchDataUnit", DataFetcher.dist.gql `query($name: String!) {
+    this.templateByQuery.set("fetchDataUnit", formConfigFetcher.dist.gql `query($name: String!) {
               $queryAlias$: fetchDataUnit(name: $name){
                 name
                 fields{
@@ -486,7 +726,7 @@ class DataUnitFetcher {
                 }
               }
             }`);
-    this.templateByQuery.set("saveData", DataFetcher.dist.gql `mutation($changes: [InputBatchChange!]!) {
+    this.templateByQuery.set("saveData", formConfigFetcher.dist.gql `mutation($changes: [InputBatchChange!]!) {
             $queryAlias$: batchOperationDataUnit(changes: $changes){
               oldId
               id
@@ -498,7 +738,7 @@ class DataUnitFetcher {
               }
             }
           }`);
-    this.templateByQuery.set("fetchDataRecord", DataFetcher.dist.gql `query($dataunit: String! $recordID: [String!]) {
+    this.templateByQuery.set("fetchDataRecord", formConfigFetcher.dist.gql `query($dataunit: String! $recordID: [String!]) {
             $queryAlias$: fetchDataUnit(name: $dataunit){
               record(id: $recordID){
                 id
@@ -510,7 +750,7 @@ class DataUnitFetcher {
               }
             }
           }`);
-    this.templateByQuery.set("fetchDistinctColumn", DataFetcher.dist.gql `query($dataUnit: String!, $fieldName: String!, $argument: String, $filters: [InputFilter], $parentRecordId: String) {
+    this.templateByQuery.set("fetchDistinctColumn", formConfigFetcher.dist.gql `query($dataUnit: String!, $fieldName: String!, $argument: String, $filters: [InputFilter], $parentRecordId: String) {
           $queryAlias$: selectDistinct(dataUnit: $dataUnit, fieldName: $fieldName, argument: $argument, filters: $filters, parentRecordId: $parentRecordId)
       }`);
   }
@@ -525,9 +765,9 @@ class DataUnitFetcher {
     return { entityName: parts[1], resourceID: parts[2] };
   }
   getDataUnit(entityName, resourceID, parentDataUnit, configName) {
-    if (PreloadManager.PreloadManager.applicationResourceID == undefined) {
+    if (PreloadManager.applicationResourceID == undefined) {
       //Por falta de um lugar melhor pra iniciar essa variável, fazemos isso aqui.
-      ResourceIDUtils.ResourceIDUtils.getResourceID().then(resourceID => PreloadManager.PreloadManager.applicationResourceID = resourceID);
+      ResourceIDUtils.ResourceIDUtils.getResourceID().then(resourceID => PreloadManager.applicationResourceID = resourceID);
     }
     const duName = `dd://${entityName}/${resourceID}${configName ? "/" + configName : ""}`;
     const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(duName) : new core.DataUnit(duName);
@@ -536,11 +776,12 @@ class DataUnitFetcher {
     dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
     dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
     dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
+    dataUnit.allRecordsLoader = (dataUnit) => DataUnitDataLoader.getCachedRecords(dataUnit);
     return dataUnit;
   }
   loadMetadata(dataUnit) {
     return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
+      formConfigFetcher.DataFetcher.get()
         .callGraphQL({
         values: { name: dataUnit.name },
         query: this.templateByQuery.get("fetchDataUnit"),
@@ -583,7 +824,7 @@ class DataUnitFetcher {
       filters: filteredFilters
     };
     return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
+      formConfigFetcher.DataFetcher.get()
         .callGraphQL({
         values,
         query: this.templateByQuery.get("fetchDistinctColumn"),
@@ -596,14 +837,41 @@ class DataUnitFetcher {
       });
     });
   }
+  addTransientProperties(dataUnit, updatingFields) {
+    const loaderProps = dataUnit.getGlobalLoaderProps();
+    if (loaderProps == undefined || loaderProps.size === 0) {
+      return updatingFields;
+    }
+    if (updatingFields == undefined) {
+      updatingFields = {};
+    }
+    Array.from(loaderProps.entries()).forEach(([name, value]) => {
+      updatingFields[`transient.${name}`] = value;
+    });
+    return updatingFields;
+  }
+  getUpdatingFields(dataUnit, originalUpdatingFields) {
+    if (originalUpdatingFields == undefined) {
+      return;
+    }
+    const updatingFields = Object.assign({}, originalUpdatingFields);
+    Object.keys(updatingFields).forEach(key => {
+      const descriptor = dataUnit.getField(key);
+      if (descriptor != undefined && descriptor.standAlone) {
+        delete updatingFields[key];
+      }
+    });
+    return this.addTransientProperties(dataUnit, updatingFields);
+  }
   saveData(dataUnit, duChanges) {
     const updatedRecordsIds = [];
     const addedRecordsIds = [];
     const changes = duChanges.map((change) => {
-      const { dataUnit: changeDU, record, updatingFields, operation } = change;
+      const { dataUnit: changeDU, record, operation } = change;
       const dataUnitInstance = core.DataUnitStorage.get(changeDU);
+      const updatingFields = this.getUpdatingFields(dataUnitInstance, change.updatingFields);
       let parsedUpdatingFields;
-      if (updatingFields) {
+      if (updatingFields != undefined) {
         parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
           const descriptor = dataUnitInstance.getField(fieldName);
           const dataType = descriptor ? descriptor.dataType : core.DataType.TEXT;
@@ -632,7 +900,7 @@ class DataUnitFetcher {
         var rest = __rest(_a, []);
         return rest;
       });
-      DataFetcher.DataFetcher.get()
+      formConfigFetcher.DataFetcher.get()
         .callGraphQL({
         values: { changes: changesFormatted },
         query: this.templateByQuery.get("saveData"),
@@ -651,7 +919,8 @@ class DataUnitFetcher {
           }
           responseRecord.fields.forEach(({ name, value }) => {
             var _a;
-            duRecord[name] = ((_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value)) || value;
+            const valueFromString = (_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value);
+            duRecord[name] = (valueFromString !== undefined) ? valueFromString : value;
           });
           dataUnitRecords.push(duRecord);
         });
@@ -672,10 +941,10 @@ class DataUnitFetcher {
     });
     if (addedRecords.length > 0) {
       const firstRecord = dataUnit.records[0];
-      PreloadManager.PreloadManager.insertRecords(dataUnit, firstRecord, addedRecords);
+      PreloadManager.insertRecords(dataUnit, firstRecord, addedRecords);
     }
     const updatedRecords = toUpdate.map(recordId => (Object.assign({}, recordsById.get(recordId))));
-    PreloadManager.PreloadManager.updateRecords(dataUnit, updatedRecords);
+    PreloadManager.updateRecords(dataUnit, updatedRecords);
   }
   getTransientInfo(dataUnit, recordID) {
     const { records } = dataUnit.getSelectionInfo();
@@ -686,13 +955,13 @@ class DataUnitFetcher {
       return { dataUnit: dataUnit.name, operation: core.ChangeOperation.DELETE, recordId, fields: this.getTransientInfo(dataUnit, recordId) };
     });
     return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
+      formConfigFetcher.DataFetcher.get()
         .callGraphQL({
         values: { changes: changes },
         query: this.templateByQuery.get("saveData"),
       })
         .then((_resp) => {
-        PreloadManager.PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
+        PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
         resolve(recordIds);
       })
         .catch((error) => {
@@ -702,7 +971,7 @@ class DataUnitFetcher {
   }
   loadRecord(dataUnit, recordIds) {
     return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
+      formConfigFetcher.DataFetcher.get()
         .callGraphQL({
         values: { recordID: recordIds, dataunit: dataUnit.name },
         query: this.templateByQuery.get("fetchDataRecord"),
@@ -726,5 +995,170 @@ class DataUnitFetcher {
   }
 }
 
+class PesquisaFetcher {
+  constructor() {
+    this._defaultPageSize = 100;
+    this._templateByQuery = new Map();
+    this._searchListenersByDataUnit = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this._templateByQuery.set("search", formConfigFetcher.dist.gql `query($entityName: String! $argument: String $criteria: InputSearchCriteria $options: InputSearchOptions) {
+                $queryAlias$: search(entityName: $entityName argument: $argument criteria: $criteria options: $options){
+                    value
+                    label
+                }
+            }`);
+  }
+  loadSearchOptions(entityName, argument, criteria, options) {
+    var _a;
+    const cleanText = (argument === null || argument === void 0 ? void 0 : argument.toString().trim()) || undefined;
+    argument = isNaN(Number(cleanText)) && cleanText ? `%${cleanText}` : cleanText;
+    criteria === null || criteria === void 0 ? void 0 : criteria.params.forEach(param => {
+      if (param.dataType === core.DataType.OBJECT) {
+        param.value = JSON.stringify(param.value);
+      }
+    });
+    const listenerResult = this.applySearchListener(SearchListenerType.beforeSearch, entityName, argument, criteria, options);
+    const values = {
+      argument: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.argument) || argument,
+      entityName,
+      criteria: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.criteria) || criteria,
+      options: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.searchOptions) || options,
+    };
+    if (values.options) {
+      (_a = values.options) === null || _a === void 0 ? true : delete _a.dataUnitId;
+    }
+    return new Promise((resolve, reject) => {
+      formConfigFetcher.DataFetcher.get()
+        .callGraphQL({
+        values,
+        query: this._templateByQuery.get("search"),
+      })
+        .then((result) => {
+        resolve(result);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadAdvancedSearch(entityName, argument, criteria, searchOptions) {
+    var _a, _b, _c, _d;
+    const listenerResult = this.applySearchListener(SearchListenerType.beforeSearch, entityName, argument, criteria, searchOptions);
+    const values = {
+      argument: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.argument) || argument,
+      criteria: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.criteria) || criteria,
+      searchOptions: Object.assign(Object.assign({}, searchOptions), listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.searchOptions),
+    };
+    const serviceName = "PesquisaSP.getSuggestion";
+    const externalCriteria = {
+      query: {
+        $: (_a = values.criteria) === null || _a === void 0 ? void 0 : _a.expression
+      }
+    };
+    if (((_c = (_b = values.criteria) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+      externalCriteria.params = {
+        param: values.criteria.params.map(param => {
+          let value = param.value;
+          if (typeof value === "string") {
+            const match = /CTX\{([^}]+)\}/.exec(value);
+            if (match) {
+              value = core.ApplicationContext.getContextValue(`__SNK__APPLICATION__FILTER__CONTEXT(${match[1]})__`);
+            }
+          }
+          let type = param.dataType;
+          if (type === core.DataType.OBJECT) {
+            value = value.value;
+            type = "S";
+          }
+          else {
+            type = convertParamType(param.dataType);
+          }
+          return { $: value, type };
+        })
+      };
+    }
+    const options = searchOptions != undefined
+      ? Object.assign(Object.assign({}, values === null || values === void 0 ? void 0 : values.searchOptions), { "pkFieldName": searchOptions.codeFieldName, "label": searchOptions.descriptionFieldName, "fieldName": searchOptions.codeFieldName, "useDescriptionOptions": false, "enableRowsCounter": true }) : undefined;
+    const reqBody = {
+      "serviceName": serviceName,
+      "requestBody": {
+        "criteria": Object.assign({ "entityName": entityName, "compacted": false, "ignoreEntityCriteria": false, "limit": this._defaultPageSize, "query": { "$": values.argument }, "orderByDesc": false, "externalCriteria": externalCriteria, "localEntityName": (_d = values.searchOptions) === null || _d === void 0 ? void 0 : _d.rootEntity }, { options }),
+        "clientEventList": {
+          "clientEvent": []
+        }
+      }
+    };
+    return new Promise((resolve, reject) => {
+      formConfigFetcher.DataFetcher.get()
+        .callServiceBroker("PesquisaSP.getSuggestion", JSON.stringify(reqBody))
+        .then(result => resolve(result))
+        .catch(error => reject(error));
+    });
+  }
+  addSearchListener(entityName, dataUnitID, listener) {
+    var _a;
+    const dataUnitSearchListeners = this._searchListenersByDataUnit.get(dataUnitID) || [];
+    const entityListener = dataUnitSearchListeners.find(currentListener => currentListener.entity === entityName);
+    if (!entityListener) {
+      this._searchListenersByDataUnit.set(dataUnitID, [...dataUnitSearchListeners, { entity: entityName, listener }]);
+    }
+    else {
+      for (const type of Object.keys(listener)) {
+        if (type in entityListener.listener) {
+          const listenerFunctionIsEquals = ((_a = entityListener.listener[type]) === null || _a === void 0 ? void 0 : _a.toString()) === listener[type].toString();
+          if (listenerFunctionIsEquals)
+            continue;
+          entityListener.listener[type] = listener[type];
+        }
+      }
+    }
+    return () => {
+      const newListeners = dataUnitSearchListeners.filter(currentListener => currentListener.entity !== entityName);
+      if (!newListeners.length) {
+        this._searchListenersByDataUnit.delete(dataUnitID);
+        return;
+      }
+      this._searchListenersByDataUnit.set(dataUnitID, newListeners);
+    };
+  }
+  applySearchListener(listenerType, entityName, argument, criteria, searchOptions) {
+    var _a;
+    const dataUnitId = searchOptions === null || searchOptions === void 0 ? void 0 : searchOptions.dataUnitId;
+    if (!dataUnitId)
+      return;
+    const entityListener = (_a = this._searchListenersByDataUnit.get(dataUnitId)) === null || _a === void 0 ? void 0 : _a.find(({ entity }) => entity === entityName);
+    if (!entityListener)
+      return;
+    const { listener } = entityListener;
+    if (!(listenerType in listener))
+      return;
+    return listener[listenerType]({ argument, criteria, searchOptions });
+  }
+}
+function convertParamType(dataType) {
+  //Alerta: Cuidado pra não contaminar o DataType com a implementação
+  //atual da pesquisa... em geral, somente inteiros,
+  //data (com ou sem hora) e string são realmente relevantes
+  switch (dataType) {
+    case core.DataType.NUMBER:
+      return "I";
+    case core.DataType.DATE:
+      return "D";
+    default:
+      return "S";
+  }
+}
+var SearchListenerType;
+(function (SearchListenerType) {
+  SearchListenerType["beforeSearch"] = "beforeSearch";
+})(SearchListenerType || (SearchListenerType = {}));
+
 exports.DataUnitFetcher = DataUnitFetcher;
 exports.InMemoryLoader = InMemoryLoader;
+exports.PesquisaFetcher = PesquisaFetcher;
+exports.PreloadManager = PreloadManager;
+exports.applyFilter = applyFilter;
+exports.applySorting = applySorting;
+exports.buildPaginationInfo = buildPaginationInfo;