@sankhyalabs/sankhyablocks 8.6.0-dev.2 → 8.6.0-dev.4

package/dist/cjs/dataunit-fetcher-9e875872.js

@@ -0,0 +1,877 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const DataFetcher = require('./DataFetcher-2a99283c.js');
+const constants = require('@sankhyalabs/ezui/dist/collection/utils/constants');
+const UnitMetadata = require('@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata');
+const ResourceIDUtils = require('./ResourceIDUtils-5ff86aa7.js');
+
+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 = core.FieldComparator.compare(dataUnit.getField(sort.field), recordA, recordB, sort.mode === core.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 === core.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 (core.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 core.DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit, request) => core.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 === core.DataType.BOOLEAN) {
+      return strValue === "S";
+    }
+    if (descriptor.dataType === core.DataType.NUMBER) {
+      return Number(strValue);
+    }
+    if (descriptor.dataType === core.DataType.DATE) {
+      return core.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 core.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 === core.ChangeOperation.INSERT ||
+          operation === core.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.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 (core.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 === core.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 === core.UserInterface.SEARCH) {
+      const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
+      if (!core.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 = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const DATA_UNIT_NAME_PARSER = /dd:\/\/([^/]+)\/([^/?]+)/;
+class DataUnitFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchDataUnit", DataFetcher.dist.gql `query($name: String!) {
+              $queryAlias$: fetchDataUnit(name: $name){
+                name
+                fields{
+                  name
+                  defaultValue
+                  label
+                  visible
+                  readOnly
+                  required
+                  dataType
+                  userInterface
+                  calculated
+                  group
+                  order
+                  properties{
+                    name
+                    value
+                  }
+                  dependencies{
+                    masterFields
+                    type
+                    expression
+                  }
+                }
+                children{
+                  name
+                  label
+                  links{
+                    source
+                    target
+                  }
+                }
+              }
+            }`);
+    this.templateByQuery.set("saveData", DataFetcher.dist.gql `mutation($changes: [InputBatchChange!]!) {
+            $queryAlias$: batchOperationDataUnit(changes: $changes){
+              oldId
+              id
+              label
+              ownerDataUnitName
+              fields {
+                name
+                value
+              }
+            }
+          }`);
+    this.templateByQuery.set("fetchDataRecord", DataFetcher.dist.gql `query($dataunit: String! $recordID: [String!]) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              record(id: $recordID){
+                id
+                label
+                fields {
+                  name
+                  value
+                }
+              }
+            }
+          }`);
+    this.templateByQuery.set("fetchDistinctColumn", DataFetcher.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)
+      }`);
+  }
+  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.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);
+    dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
+    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);
+    return dataUnit;
+  }
+  loadMetadata(dataUnit) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataUnit"),
+      })
+        .then((resp) => {
+        var _a;
+        const metadata = {
+          name: resp.name,
+          label: resp.name,
+          children: [...resp.children],
+          fields: []
+        };
+        (_a = resp.fields) === null || _a === void 0 ? void 0 : _a.forEach((source) => {
+          let properties = undefined;
+          if (Array.isArray(source.properties)) {
+            properties = {};
+            if (source.calculated) {
+              properties.gridHeaderTooltip = "Campos calculados não podem ser ordenados";
+            }
+            source.properties.forEach((prop) => (properties[prop.name] = prop.value));
+          }
+          metadata.fields.push(Object.assign(Object.assign({}, source), { properties }));
+        });
+        metadata.fields.sort((a, b) => a.order - b.order);
+        resolve(metadata);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadSelectDistinct(dataUnit, fieldName, argument) {
+    const { parentRecordId, filters } = dataUnit.getLastLoadRequest() || {};
+    const filteredFilters = filters.filter(f => f.name !== `${constants.DISTINCT_FILTER_NAME_PREFIX}${fieldName}`);
+    const values = {
+      dataUnit: dataUnit.name,
+      argument,
+      fieldName,
+      parentRecordId,
+      filters: filteredFilters
+    };
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values,
+        query: this.templateByQuery.get("fetchDistinctColumn"),
+      })
+        .then((result) => {
+        resolve(result);
+      })
+        .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 = core.DataUnitStorage.get(changeDU);
+      let parsedUpdatingFields;
+      if (updatingFields) {
+        parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
+          const descriptor = dataUnitInstance.getField(fieldName);
+          const dataType = descriptor ? descriptor.dataType : core.DataType.TEXT;
+          return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
+        });
+      }
+      if (changeDU === dataUnit.name) {
+        if (operation === core.ChangeOperation.INSERT || operation === core.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;
+      }
+      if (record.__parent__record__id__) {
+        reqChange.parentRecordId = record.__parent__record__id__;
+      }
+      return reqChange;
+    });
+    return new Promise((resolve, reject) => {
+      const changesFormatted = changes.map((_a) => {
+        var rest = __rest(_a, []);
+        return rest;
+      });
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changesFormatted },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((resp) => {
+        const dataUnitRecords = [];
+        resp === null || resp === void 0 ? void 0 : resp.forEach((responseRecord) => {
+          const duRecord = {
+            __record__id__: responseRecord.id,
+            __record__label__: responseRecord.label,
+            __owner__dataunit__name__: responseRecord.ownerDataUnitName,
+          };
+          const dataUnitInstance = core.DataUnitStorage.get(duRecord.__owner__dataunit__name__) || dataUnit;
+          if (responseRecord.oldId) {
+            duRecord.__old__id__ = responseRecord.oldId;
+          }
+          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;
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        this.updateCache(dataUnit, dataUnitRecords, updatedRecordsIds, addedRecordsIds);
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  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(UnitMetadata.DataUnitTransient.DATA_UNIT_TRANSIENT_PREFIX_NAME)).map(([name, value]) => ({ fieldName: name, value, dataType: core.DataType.TEXT }));
+  }
+  removeRecords(dataUnit, recordIds) {
+    const changes = recordIds.map((recordId) => {
+      return { dataUnit: dataUnit.name, operation: core.ChangeOperation.DELETE, recordId, fields: this.getTransientInfo(dataUnit, recordId) };
+    });
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changes },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((_resp) => {
+        PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
+        resolve(recordIds);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadRecord(dataUnit, recordIds) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { recordID: recordIds, dataunit: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataRecord"),
+      })
+        .then((response) => {
+        const dataUnitRecords = [];
+        response.record.forEach(responseRecord => {
+          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        //TODO: Chamar o worker para persistir a nova versão do registro
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+exports.DataUnitFetcher = DataUnitFetcher;
+exports.InMemoryLoader = InMemoryLoader;
+exports.PreloadManager = PreloadManager;