@sankhyalabs/sankhyablocks 8.6.0-dev.3 → 8.6.0-rc.1

package/dist/components/dataunit-fetcher.js

@@ -1,7 +1,742 @@
-import { DataUnit, StringUtils, DataType, DataUnitStorage, ChangeOperation } from '@sankhyalabs/core';
+import { DataType, FieldComparator, SortMode, DataUnit, defaultDataLoader, DateUtils, StringUtils, ChangeOperation, UserInterface, DataUnitStorage } from '@sankhyalabs/core';
 import { d as dist, D as DataFetcher } from './DataFetcher.js';
 import { DISTINCT_FILTER_NAME_PREFIX } from '@sankhyalabs/ezui/dist/collection/utils/constants';
 import { DataUnitTransient } from '@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata';
+import { R as ResourceIDUtils } from './ResourceIDUtils.js';
+
+class PesquisaFetcher {
+  constructor() {
+    this._defaultPageSize = 100;
+    this._templateByQuery = new Map();
+    this._searchListenersByDataUnit = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this._templateByQuery.set("search", 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 === 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) => {
+      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;
+    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: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.searchOptions) || searchOptions,
+    };
+    const serviceName = "PesquisaSP.getSuggestion";
+    const externalCriteria = {
+      query: {
+        $: (_a = values.criteria) === null || _a === void 0 ? void 0 : _a.expression
+      }
+    };
+    if (((_b = values.criteria) === null || _b === void 0 ? void 0 : _b.params.length) > 0) {
+      externalCriteria.params = {
+        param: values.criteria.params.map(param => {
+          let value = param.value;
+          let type = param.dataType;
+          if (type === DataType.OBJECT) {
+            value = value.value;
+            type = "S";
+          }
+          else {
+            type = convertParamType(param.dataType);
+          }
+          return { $: value, type };
+        })
+      };
+    }
+    const options = searchOptions != undefined
+      ? {
+        "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": (_c = values.searchOptions) === null || _c === void 0 ? void 0 : _c.rootEntity }, { options }),
+        "clientEventList": {
+          "clientEvent": []
+        }
+      }
+    };
+    return new Promise((resolve, reject) => {
+      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 DataType.NUMBER:
+      return "I";
+    case DataType.DATE:
+      return "D";
+    default:
+      return "S";
+  }
+}
+var SearchListenerType;
+(function (SearchListenerType) {
+  SearchListenerType["beforeSearch"] = "beforeSearch";
+})(SearchListenerType || (SearchListenerType = {}));
+
+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 = this._list.map(item => itemProcessor(item));
+    return Promise.resolve(new Map(processedItems.filter(item => item != undefined)
+      .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 => !items.includes(item));
+  }
+  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);
+  }
+}
+
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+class PreloadManager {
+  static setLoadingStatus(dataUnit, loadingInProgress) {
+    this._loadingStatus.set(dataUnit.name, loadingInProgress);
+  }
+  static isCacheEnabled(dataUnit) {
+    const dataUnitResourceId = PreloadManager.getResourceId(dataUnit.name);
+    if (dataUnitResourceId !== this.applicationResourceID) {
+      return false;
+    }
+    return this.getRepository(dataUnit).isOperating();
+  }
+  static getResourceId(dataUnitName) {
+    const dataUnitNameInfo = DataUnitFetcher.parseDataUnitName(dataUnitName);
+    return dataUnitNameInfo == undefined ? undefined : dataUnitNameInfo.resourceID;
+  }
+  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) {
+    if (sorting == undefined || sorting.length == 0) {
+      return undefined;
+    }
+    return (recordA, recordB) => {
+      for (const sort of sorting) {
+        const result = FieldComparator.compare(dataUnit.getField(sort.field), recordA, recordB, sort.mode === SortMode.ASC);
+        if (result != 0) {
+          return result;
+        }
+      }
+    };
+  }
+  static async getDistinct(dataUnit, fieldName) {
+    if (!PreloadManager.isCacheEnabled(dataUnit)) {
+      return Promise.resolve(undefined);
+    }
+    return new Promise((accept, reject) => {
+      PreloadManager.getRepository(dataUnit).distict(record => {
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return undefined;
+        }
+        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        return { key: dataUnit.getFormattedValue(fieldName, fieldValue), value };
+      })
+        .then(values => accept(values))
+        .catch(reason => reject(reason));
+    });
+  }
+  static async loadData(dataUnit, request, loadFromServer) {
+    try {
+      if (PreloadManager.isCacheEnabled(dataUnit)) {
+        let useCache = request.source === "EZ_GRID_LOADING_SOURCE" || request.source === DataUnit.CHANGING_PAGE_LOADING_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 limpado.
+        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 getFilterFunction(dataUnit, filters) {
+    if (filters != undefined && filters.length > 0) {
+      return record => {
+        for (const filter of filters) {
+          if (!PreloadManager.recordMatchesFilter(dataUnit, record, filter)) {
+            return false;
+          }
+        }
+        return true;
+      };
+    }
+    return undefined;
+  }
+  static recordMatchesFilter(dataUnit, record, columnFilter) {
+    const fieldValue = record[columnFilter.columnName];
+    for (let param of columnFilter.params) {
+      const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
+      if (FieldComparator.compareValues(dataUnit.getField(columnFilter.columnName), fieldValue, paramValue) === 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static async loadFromCache(dataUnit, request) {
+    return new Promise((accept, reject) => {
+      const columnFilters = PreloadManager.getColumnFilters(request.filters);
+      const { limit, offset, sort } = request;
+      PreloadManager.getRepository(dataUnit)
+        .load(PreloadManager.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 ? 1 : 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 getColumnFilters(filters) {
+    const columnFilters = new Map();
+    if (filters == undefined || filters.length == 0) {
+      return columnFilters;
+    }
+    filters.forEach(filter => {
+      const match = COLUMN_FILTER_PATTERN.exec(filter.name);
+      if (match) {
+        columnFilters.set(filter.name, Object.assign({ columnName: match[1] }, filter));
+      }
+    });
+    return columnFilters;
+  }
+}
+PreloadManager._repositories = new Map();
+PreloadManager._loadingStatus = new Map();
+
+class InMemoryLoader {
+  constructor(metadata, records) {
+    this.metadata = metadata;
+    this.records = records;
+    this._dataUnit = new DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit, request) => defaultDataLoader(dataUnit, request, this.getRecordsToLoad());
+    this._dataUnit.saveLoader = (_dataUnit, changes) => this.saveLoader(_dataUnit, changes);
+    this._dataUnit.removeLoader = (_dataUnit, recordIds) => this.removeLoader(_dataUnit, recordIds);
+    this.dataUnit.loadMetadata().then(() => this.dataUnit.loadData());
+  }
+  getRecordsToLoad() {
+    if (this._initialRecords) {
+      try {
+        return this._initialRecords;
+      }
+      finally {
+        this._initialRecords = undefined;
+      }
+    }
+    return this.dataUnit.records;
+  }
+  get dataUnit() {
+    return this._dataUnit;
+  }
+  get records() {
+    return this.dataUnit.records;
+  }
+  static getConvertedValue(descriptor, strValue) {
+    if (descriptor.dataType === DataType.BOOLEAN) {
+      return strValue === "S";
+    }
+    if (descriptor.dataType === DataType.NUMBER) {
+      return Number(strValue);
+    }
+    if (descriptor.dataType === DataType.DATE) {
+      return DateUtils.strToDate(strValue, true);
+    }
+    return strValue;
+  }
+  set records(records) {
+    const columns = this._metadata ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor])) : undefined;
+    const newRecords = records === null || records === void 0 ? void 0 : records.map(record => {
+      if (!record["__record__id__"]) {
+        record["__record__id__"] = this.generateUniqueId();
+      }
+      if (columns != undefined) {
+        for (const name in record) {
+          const value = record[name];
+          if (typeof value === "string" && columns.has(name)) {
+            record[name] = InMemoryLoader.getConvertedValue(columns.get(name), value);
+          }
+        }
+      }
+      return record;
+    });
+    if (this._dataUnit) {
+      this._dataUnit.records = newRecords;
+    }
+    else {
+      this._initialRecords = newRecords;
+    }
+  }
+  get metadata() {
+    return this._metadata;
+  }
+  set metadata(metadata) {
+    this._metadata = metadata;
+    if (this._dataUnit) {
+      this._dataUnit.metadata = this._metadata;
+    }
+  }
+  generateUniqueId() {
+    return StringUtils.generateUUID();
+  }
+  metadaLoader() {
+    return Promise.resolve(this._metadata);
+  }
+  saveLoader(_dataUnit, changes) {
+    return new Promise((resolve) => {
+      let dataUnitRecords = [];
+      changes.forEach(change => {
+        let { record, updatingFields, operation } = change;
+        const changedRecord = Object.assign(Object.assign({}, record), updatingFields);
+        if (operation === ChangeOperation.INSERT ||
+          operation === ChangeOperation.COPY) {
+          changedRecord["__old__id__"] = record["__record__id__"];
+          changedRecord["__record__id__"] = this.generateUniqueId();
+          this.records.push(changedRecord);
+        }
+        else {
+          const recordIndex = this.records.findIndex(r => r["__record__id__"] == changedRecord["__record__id__"]);
+          this.records[recordIndex] = changedRecord;
+        }
+        dataUnitRecords.push(changedRecord);
+      });
+      resolve(dataUnitRecords);
+    });
+  }
+  removeLoader(_dataUnit, recordIds) {
+    return new Promise((resolve) => {
+      resolve(recordIds);
+    });
+  }
+}
+InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";
+
+class DatasetStrategy {
+  canSlice() {
+    return false;
+  }
+  async load(dataUnit, request, loadingInfo) {
+    if (dataUnit.metadata == undefined) {
+      return Promise.resolve({ records: [], loadingInfo });
+    }
+    try {
+      const fields = this.getFieldsList(dataUnit);
+      const serviceName = "DatasetSP.loadRecords";
+      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo);
+      const { result: responseRecords, pagerID: pagerId } = await DataFetcher.get().callServiceBroker(serviceName, requestBody);
+      const records = this.processRecords(dataUnit, fields, responseRecords);
+      const loadingInProgress = pagerId != undefined;
+      const count = loadingInfo.count + records.length;
+      return Promise.resolve({
+        records,
+        loadingInfo: Object.assign(Object.assign({}, loadingInfo), { pagerId,
+          loadingInProgress, total: loadingInProgress ? undefined : count, count })
+      });
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  getFieldsList(dataUnit) {
+    let fields = ["__record__id__", "__record__label__"];
+    dataUnit.metadata.fields.forEach(descriptor => {
+      fields = fields.concat(this.getFieldNames(descriptor));
+    });
+    return fields;
+  }
+  getFieldNames(descriptor) {
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField == undefined) {
+      return descriptor.name;
+    }
+    return [descriptor.name, descriptionField];
+  }
+  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo) {
+    const dataSetID = dataUnit.dataUnitId;
+    const dataUnitName = dataUnit.name;
+    const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
+    const requestBody = {
+      serviceName,
+      requestBody: {
+        dataSetID,
+        fields,
+        entityName,
+        pageNumber: loadingInfo.pageNumber,
+        totalRecordsCount: loadingInfo.count,
+        pagerID: loadingInfo.pagerId,
+        standAlone: false,
+        standAloneFieldsMD: {
+          __record__id__: { "fieldType": "S", "userType": "P" },
+          __record__label__: { "fieldType": "S", "userType": "P" }
+        },
+        tryJoinedFields: true,
+        parallelLoader: true,
+        crudListener: "br.com.sankhya.modelcore.dataset.DataUnitDatasetAdapter",
+        txProperties: this.getTxProperties(dataUnitName, request),
+        useDefaultRowsLimit: false
+      }
+    };
+    return JSON.stringify(requestBody);
+  }
+  getTxProperties(dataUnitName, request) {
+    const txProperties = {
+      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnitName
+    };
+    const serverSideFilters = request.filters.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"));
+    if (serverSideFilters.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
+    }
+    const sorting = request.sort;
+    if (sorting != undefined && sorting.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[sorting]"] = JSON.stringify(sorting);
+    }
+    return txProperties;
+  }
+  processRecords(dataUnit, fields, responseRecords) {
+    return responseRecords.map((dataFrame) => {
+      const duRecord = {
+        __record__id__: dataFrame[0],
+        __record__label__: dataFrame[1]
+      };
+      dataUnit.metadata.fields.forEach(fieldDescriptor => {
+        duRecord[fieldDescriptor.name] = this.buildFieldValue(fieldDescriptor, fields, dataFrame);
+      });
+      return duRecord;
+    });
+  }
+  buildFieldValue(descriptor, allFields, dataFrame) {
+    const fieldIndex = allFields.indexOf(descriptor.name);
+    if (fieldIndex < 0) {
+      return null;
+    }
+    const strValue = dataFrame[fieldIndex];
+    if (StringUtils.isEmpty(strValue)) {
+      return null;
+    }
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField != undefined) {
+      const descriptionFieldIndex = allFields.indexOf(descriptionField);
+      if (descriptionFieldIndex >= 0) {
+        return { value: strValue, label: dataFrame[descriptionFieldIndex] };
+      }
+    }
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      //Se não tem um campo de descrição (código acima)
+      //Mas é um search, tentamos parsear um numero...
+      return isNaN(Number(strValue)) ? strValue : Number(strValue);
+    }
+    return InMemoryLoader.getConvertedValue(descriptor, strValue);
+  }
+  getSearchDescriptionField(descriptor) {
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
+      if (!StringUtils.isEmpty(DESCRIPTIONFIELD)) {
+        return mergedFrom != undefined ? `${mergedFrom}.${ENTITYNAME}.${DESCRIPTIONFIELD}` : `${ENTITYNAME}.${DESCRIPTIONFIELD}`;
+      }
+    }
+    return undefined;
+  }
+}
+
+class DataUnitDataLoader {
+  static async debounce(dataUnit, callBack) {
+    const duName = dataUnit.name;
+    if (DataUnitDataLoader._debouncingTimeouts[duName]) {
+      clearTimeout(DataUnitDataLoader._debouncingTimeouts[duName]);
+      delete DataUnitDataLoader._debouncingTimeouts[duName];
+    }
+    DataUnitDataLoader._debouncingTimeouts[duName] = setTimeout(() => {
+      delete DataUnitDataLoader._debouncingTimeouts[duName];
+      callBack();
+    }, 100);
+  }
+  static async loadData(dataUnit, request) {
+    return new Promise((resolve, reject) => {
+      DataUnitDataLoader.debounce(dataUnit, () => {
+        PreloadManager.loadData(dataUnit, request, this.loadFromServer)
+          .then(resp => resolve(resp))
+          .catch(reason => reject(reason));
+      });
+    });
+  }
+  static async loadFromServer(dataUnit, request, loadingInfo) {
+    try {
+      //Registramos a request com as informações de carga para determinarmos a última.
+      //Caso o usuário inicie outro refresh antes de terminar, devemos ignorar o resultado.
+      loadingInfo = DataUnitDataLoader.registryLoading(dataUnit, loadingInfo);
+      const loadResult = await DataUnitDataLoader.callLoader(dataUnit, request, loadingInfo);
+      if (loadResult == undefined) {
+        //Essa request foi originada de refresh antigo. Será ignorada;
+        return;
+      }
+      const loadedRecords = loadResult.records;
+      const paginationInfo = DataUnitDataLoader.buildPaginationInfo(loadedRecords.length, request, loadResult.loadingInfo);
+      const records = paginationInfo == undefined ? loadedRecords : loadedRecords.slice(0, paginationInfo.lastRecord);
+      return Promise.resolve({ records, paginationInfo });
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  static async callLoader(dataUnit, request, requestLoadingInfo, dataLoader) {
+    if (dataLoader == undefined) {
+      //dataLoader = new DataUnitStrategy();
+      dataLoader = new DatasetStrategy();
+    }
+    const result = await dataLoader.load(dataUnit, request, requestLoadingInfo);
+    const { records, loadingInfo: responseLoadingInfo } = result;
+    if (DataUnitDataLoader.isOldRequest(dataUnit, responseLoadingInfo)) {
+      return Promise.resolve(undefined);
+    }
+    const recreateCache = !dataLoader.canSlice() || responseLoadingInfo.count === 0;
+    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 });
+      this.callLoader(dataUnit, newRequest, newLoadingInfo, dataLoader)
+        .then(result => DataUnitDataLoader.afterLoadingPage(dataUnit, result.loadingInfo))
+        .catch(reason => console.error(reason));
+    }
+    return Promise.resolve(result);
+  }
+  static afterLoadingPage(dataUnit, loadingInfo) {
+    PreloadManager.setLoadingStatus(dataUnit, loadingInfo.loadingInProgress);
+    const dataUnitPagination = dataUnit.getPaginationInfo();
+    if (dataUnitPagination == undefined) {
+      return;
+    }
+    const count = loadingInfo.count;
+    if (loadingInfo.loadingInProgress) {
+      dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { count }));
+      return;
+    }
+    dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { total: count, count }));
+  }
+  static registryLoading(dataUnit, loadingInfo) {
+    if (loadingInfo == undefined) {
+      loadingInfo = { requestTime: new Date().getTime(), count: 0 };
+    }
+    DataUnitDataLoader._requestTimeByDataUnit.set(dataUnit.name, loadingInfo.requestTime);
+    return loadingInfo;
+  }
+  static isOldRequest(dataUnit, loadingInfo) {
+    return DataUnitDataLoader._requestTimeByDataUnit.get(dataUnit.name) > loadingInfo.requestTime;
+  }
+  static buildPaginationInfo(pageSize, request, loadingInfo) {
+    let { limit, offset } = request;
+    if (!limit) {
+      return undefined;
+    }
+    if (loadingInfo.pageNumber === 1) {
+      // Quando o loader não é capaz de fatiar os registros
+      // ele pode decidir por uma carga completa, o que faz o
+      // controle de paginação voltar pra primeira página.
+      offset = 0;
+    }
+    const { total, count, loadingInProgress } = loadingInfo;
+    const lastRecord = offset + Math.min(pageSize, limit);
+    return {
+      total,
+      count,
+      lastRecord,
+      firstRecord: offset + 1,
+      currentPage: offset / limit,
+      hasMore: lastRecord < count || loadingInProgress
+    };
+  }
+}
+DataUnitDataLoader._requestTimeByDataUnit = new Map();
+DataUnitDataLoader._debouncingTimeouts = {};
 
 var __rest = (undefined && undefined.__rest) || function (s, e) {
   var t = {};
@@ -14,10 +749,10 @@ var __rest = (undefined && undefined.__rest) || function (s, e) {
     }
   return t;
 };
+const DATA_UNIT_NAME_PARSER = /dd:\/\/([^/]+)\/([^/?]+)/;
 class DataUnitFetcher {
   constructor() {
     this.templateByQuery = new Map();
-    this._loadDataTimeout = {};
     this.buldTemplates();
   }
   buldTemplates() {
@@ -56,24 +791,6 @@ class DataUnitFetcher {
                 }
               }
             }`);
-    this.templateByQuery.set("fetchData", dist.gql `query($dataunit: String! $limit: Int $offset:Int $filters: [InputFilter!] $sort: [InputSort!] $parentRecordId: String) {
-            $queryAlias$: fetchDataUnit(name: $dataunit){
-              data(limit: $limit offset: $offset filters: $filters sort: $sort parentRecordId: $parentRecordId){
-                limit
-                offset
-                total
-                hasMore
-                records{
-                  id
-                  label
-                  fields {
-                    name
-                    value
-                  }
-                }
-              }
-            }
-          }`);
     this.templateByQuery.set("saveData", dist.gql `mutation($changes: [InputBatchChange!]!) {
             $queryAlias$: batchOperationDataUnit(changes: $changes){
               oldId
@@ -102,11 +819,25 @@ class DataUnitFetcher {
           $queryAlias$: selectDistinct(dataUnit: $dataUnit, fieldName: $fieldName, argument: $argument, filters: $filters, parentRecordId: $parentRecordId)
       }`);
   }
+  static parseDataUnitName(name) {
+    if (name == undefined) {
+      return undefined;
+    }
+    const parts = DATA_UNIT_NAME_PARSER.exec(name);
+    if (!parts) {
+      return undefined;
+    }
+    return { entityName: parts[1], resourceID: parts[2] };
+  }
   getDataUnit(entityName, resourceID, parentDataUnit, configName) {
+    if (PreloadManager.applicationResourceID == undefined) {
+      //Por falta de um lugar melhor pra iniciar essa variável, fazemos isso aqui.
+      ResourceIDUtils.getResourceID().then(resourceID => PreloadManager.applicationResourceID = resourceID);
+    }
     const duName = `dd://${entityName}/${resourceID}${configName ? "/" + configName : ""}`;
     const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(duName) : new DataUnit(duName);
     dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
-    dataUnit.dataLoader = (dataUnit, request) => this.loadData(dataUnit, request);
+    dataUnit.dataLoader = (dataUnit, request) => DataUnitDataLoader.loadData(dataUnit, request);
     dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
     dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
     dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
@@ -146,24 +877,6 @@ class DataUnitFetcher {
       });
     });
   }
-  async loadData(dataUnit, request) {
-    try {
-      const duName = dataUnit.name;
-      if (this._loadDataTimeout[duName]) {
-        clearTimeout(this._loadDataTimeout[duName]);
-        delete this._loadDataTimeout[duName];
-      }
-      const result = await this.doLoadData(dataUnit, request);
-      delete this._loadDataTimeout[duName];
-      await new Promise(resolve => {
-        this._loadDataTimeout[duName] = setTimeout(resolve, 200);
-      });
-      return Promise.resolve(result);
-    }
-    catch (error) {
-      return Promise.reject(error);
-    }
-  }
   loadSelectDistinct(dataUnit, fieldName, argument) {
     const { parentRecordId, filters } = dataUnit.getLastLoadRequest() || {};
     const filteredFilters = filters.filter(f => f.name !== `${DISTINCT_FILTER_NAME_PREFIX}${fieldName}`);
@@ -188,67 +901,9 @@ class DataUnitFetcher {
       });
     });
   }
-  doLoadData(dataUnit, request) {
-    return new Promise((resolve, reject) => {
-      var _a;
-      const { sort, filters, limit, offset, quickFilter } = request;
-      const variables = { dataunit: dataUnit.name, sort, filters };
-      variables.limit = limit;
-      variables.offset = offset;
-      variables.parentRecordId = request.parentRecordId;
-      if (!StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
-        if (variables.filter === undefined) {
-          variables.filter = [];
-        }
-        const quickFilterCriteria = {
-          name: "__QUICK_FILTER__",
-          expression: "__QUICK_FILTER__",
-          params: [{ name: "term", dataType: DataType.TEXT, value: quickFilter.term }]
-        };
-        if (((_a = quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-          quickFilterCriteria.params.push({ name: "fields", dataType: DataType.OBJECT, value: quickFilter.fields });
-        }
-        variables.filter.push(quickFilterCriteria);
-      }
-      DataFetcher.get()
-        .callGraphQL({
-        values: variables,
-        query: this.templateByQuery.get("fetchData"),
-      })
-        .then((resp) => {
-        const { limit, offset, total, hasMore, records } = resp.data;
-        let paginationInfo;
-        if (limit) {
-          const firstRecord = total == 0 ? 0 : offset + 1;
-          const lastRecord = offset + Math.min(records.length, limit);
-          const currentPage = offset / limit;
-          paginationInfo = {
-            firstRecord,
-            lastRecord,
-            total,
-            currentPage,
-            hasMore
-          };
-        }
-        const processedRecords = [];
-        records.forEach((responseRecord) => {
-          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
-          responseRecord.fields.forEach(({ name, value }) => {
-            duRecord[name] = dataUnit.valueFromString(name, value);
-          });
-          processedRecords.push(duRecord);
-        });
-        resolve({
-          paginationInfo,
-          records: processedRecords
-        });
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
   saveData(dataUnit, duChanges) {
+    const updatedRecordsIds = [];
+    const addedRecordsIds = [];
     const changes = duChanges.map((change) => {
       const { dataUnit: changeDU, record, updatingFields, operation } = change;
       const dataUnitInstance = DataUnitStorage.get(changeDU);
@@ -260,6 +915,14 @@ class DataUnitFetcher {
           return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
         });
       }
+      if (changeDU === dataUnit.name) {
+        if (operation === ChangeOperation.INSERT || operation === ChangeOperation.COPY) {
+          addedRecordsIds.push(record.__record__id__);
+        }
+        else {
+          updatedRecordsIds.push(record.__record__id__);
+        }
+      }
       const reqChange = { dataUnit: changeDU, fields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
       if (change.sourceId) {
         reqChange.sourceId = change.sourceId;
@@ -297,6 +960,7 @@ class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        this.updateCache(dataUnit, dataUnitRecords, updatedRecordsIds, addedRecordsIds);
         resolve(dataUnitRecords);
       })
         .catch((error) => {
@@ -304,6 +968,20 @@ class DataUnitFetcher {
       });
     });
   }
+  updateCache(dataUnit, savedRecords, toUpdate, toInsert) {
+    const recordsById = new Map(savedRecords.map(record => [record.__old__id__ || record.__record__id__, record]));
+    const addedRecords = toInsert.map(recordId => {
+      const copy = Object.assign({}, recordsById.get(recordId));
+      delete copy.__old__id__;
+      return copy;
+    });
+    if (addedRecords.length > 0) {
+      const firstRecord = dataUnit.records[0];
+      PreloadManager.insertRecords(dataUnit, firstRecord, addedRecords);
+    }
+    const updatedRecords = toUpdate.map(recordId => (Object.assign({}, recordsById.get(recordId))));
+    PreloadManager.updateRecords(dataUnit, updatedRecords);
+  }
   getTransientInfo(dataUnit, recordID) {
     const { records } = dataUnit.getSelectionInfo();
     return Object.entries(records.filter(record => record.__record__id__ == recordID)[0]).filter(([key]) => key.startsWith(DataUnitTransient.DATA_UNIT_TRANSIENT_PREFIX_NAME)).map(([name, value]) => ({ fieldName: name, value, dataType: DataType.TEXT }));
@@ -319,6 +997,7 @@ class DataUnitFetcher {
         query: this.templateByQuery.get("saveData"),
       })
         .then((_resp) => {
+        PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
         resolve(recordIds);
       })
         .catch((error) => {
@@ -342,6 +1021,7 @@ class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        //TODO: Chamar o worker para persistir a nova versão do registro
         resolve(dataUnitRecords);
       })
         .catch((error) => {
@@ -351,4 +1031,4 @@ class DataUnitFetcher {
   }
 }
 
-export { DataUnitFetcher as D };
+export { DataUnitFetcher as D, InMemoryLoader as I, PesquisaFetcher as P, PreloadManager as a };