@sankhyalabs/sankhyablocks 8.7.0 → 8.8.0-dev.2

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/cache/ArrayRepository.js

@@ -0,0 +1,77 @@
+export 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) {
+        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);
+  }
+}

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/cache/PreloadManager.js

@@ -0,0 +1,179 @@
+import { DataUnit, FieldComparator, SortMode } from "@sankhyalabs/core";
+import DataUnitFetcher from "../dataunit-fetcher";
+import { ArrayRepository } from "./ArrayRepository";
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+export default 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(result => {
+        if (result != undefined && result.size > 0) {
+          const field = dataUnit.getField(fieldName);
+          const sortedMap = new Map(Array.from(result.entries())
+            .sort((itemA, itemB) => FieldComparator.compareValues(field, itemA[1], itemB[1]))
+            .map(([key, value]) => key === "" ? ["(Vazio)", value] : [key, value]));
+          accept(sortedMap);
+          return;
+        }
+        accept(result);
+      })
+        .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();

package/dist/collection/lib/http/data-fetcher/fetchers/{dataunit-fetcher.js → data-unit/dataunit-fetcher.js}

@@ -10,15 +10,18 @@ var __rest = (this && this.__rest) || function (s, e) {
     }
   return t;
 };
-import { ChangeOperation, DataType, DataUnit, StringUtils, DataUnitStorage } from "@sankhyalabs/core";
+import { ChangeOperation, DataType, DataUnit, DataUnitStorage } from "@sankhyalabs/core";
 import { gql } from "graphql-request";
-import { DataFetcher } from "../DataFetcher";
+import { DataFetcher } from "../../DataFetcher";
 import { DISTINCT_FILTER_NAME_PREFIX } from "@sankhyalabs/ezui/dist/collection/utils/constants";
 import { DataUnitTransient } from "@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata";
+import DataUnitDataLoader from "./DataUnitDataLoader";
+import PreloadManager from "./cache/PreloadManager";
+import ResourceIDUtils from "../../../../resourceid/ResourceIDUtils";
+const DATA_UNIT_NAME_PARSER = /dd:\/\/([^/]+)\/([^/?]+)/;
 export default class DataUnitFetcher {
   constructor() {
     this.templateByQuery = new Map();
-    this._loadDataTimeout = {};
     this.buldTemplates();
   }
   buldTemplates() {
@@ -57,24 +60,6 @@ export default class DataUnitFetcher {
                 }
               }
             }`);
-    this.templateByQuery.set("fetchData", 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", gql `mutation($changes: [InputBatchChange!]!) {
             $queryAlias$: batchOperationDataUnit(changes: $changes){
               oldId
@@ -103,11 +88,25 @@ export default 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);
@@ -147,24 +146,6 @@ export default 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}`);
@@ -189,67 +170,9 @@ export default 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);
@@ -261,6 +184,14 @@ export default 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;
@@ -298,6 +229,7 @@ export default class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        this.updateCache(dataUnit, dataUnitRecords, updatedRecordsIds, addedRecordsIds);
         resolve(dataUnitRecords);
       })
         .catch((error) => {
@@ -305,6 +237,20 @@ export default 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 }));
@@ -320,6 +266,7 @@ export default 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) => {
@@ -343,6 +290,7 @@ export default class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        //TODO: Chamar o worker para persistir a nova versão do registro
         resolve(dataUnitRecords);
       })
         .catch((error) => {

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadDataResult.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadDataStrategy.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadingInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/IRecordField.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/IResponseRecord.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/loadstrategy/DataUnitStrategy.js

@@ -0,0 +1,68 @@
+import { DataType, StringUtils } from "@sankhyalabs/core";
+import { DataFetcher } from "../../../DataFetcher";
+import { gql } from "graphql-request";
+const GQL_QUERY = 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
+          }
+        }
+      }
+    }
+  }`;
+export class DataUnitStrategy {
+  canSlice() {
+    return true;
+  }
+  getVariables(dataunit, request) {
+    var _a;
+    let { sort, filters, limit, offset, quickFilter, parentRecordId } = request;
+    if (!StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
+      const quickFilterCriteria = {
+        name: "__QUICK_FILTER__",
+        expression: "__QUICK_FILTER__",
+        params: [{ name: "term", dataType: DataType.TEXT, value: quickFilter.term }]
+      };
+      if (((_a = quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        quickFilterCriteria.params.push({ name: "fields", dataType: DataType.OBJECT, value: quickFilter.fields });
+      }
+      if (filters === undefined) {
+        filters = [];
+      }
+      filters.push(quickFilterCriteria);
+    }
+    return { dataunit, sort, filters, limit, offset, parentRecordId };
+  }
+  async load(dataUnit, request, loadingInfo) {
+    return new Promise((accept, reject) => {
+      DataFetcher.get().callGraphQL({
+        values: this.getVariables(dataUnit.name, request),
+        query: GQL_QUERY
+      }, false)
+        .then(resp => {
+        const { hasMore, records: responseRecords, total } = resp.data;
+        const records = responseRecords.map((record) => {
+          const duRecord = { __record__id__: record.id, __record__label__: record.label };
+          record.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          return duRecord;
+        });
+        accept({
+          records,
+          loadingInfo: Object.assign(Object.assign({}, loadingInfo), { loadingInProgress: hasMore, total, count: loadingInfo.count + records.length })
+        });
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+}