@po-ui/ng-sync 5.22.3 → 6.2.0

package/{esm2015/lib/services/po-schema/po-schema-util/po-schema-util.model.js → esm2020/lib/services/po-schema/po-schema-util/po-schema-util.model.mjs}

@@ -1,124 +1,124 @@
-/**
- * @docsPrivate
- *
- * @description
- *
- * Serviço utilitário para operações no PoSyncSchema.
- */
-export class PoSchemaUtil {
-    /**
-     * Verica se existem campos locais no *schema* informado.
-     *
-     * @param {PoSyncSchema} schema **Schema* a ser processado.
-     *
-     * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.
-     */
-    static containsLocalFields(schema) {
-        if (schema.fields) {
-            return !!schema.fields.find(field => typeof field === 'object' && field.local);
-        }
-    }
-    /**
-     * Retorna o valor atual do `lastSync` para determinado *schema*.
-     *
-     * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.
-     * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.
-     *
-     * @returns {string} Retorna uma *string* com o valor da última sincronização.
-     */
-    static getLastSync(storageSchemas, schemaName) {
-        if (storageSchemas) {
-            const schemaFound = storageSchemas.find(schema => schema.name === schemaName);
-            return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;
-        }
-        return PoSchemaUtil.defaultLastSync;
-    }
-    /**
-     * Retorna a lista de campos locais definidos no *schema*.
-     *
-     * @param {PoSyncSchema} schema **Schema* a ser processado.
-     */
-    static getLocalFieldNames(schema) {
-        if (schema.fields) {
-            return schema.fields.reduce((fieldsAccumulator, currentField) => {
-                if (typeof currentField === 'object' && currentField.local) {
-                    fieldsAccumulator.push(currentField.name);
-                }
-                return fieldsAccumulator;
-            }, []);
-        }
-    }
-    /**
-     * Retorna a lista de campos não locais definidos no *schema*.
-     *
-     * @param {PoSyncSchema} schema **Schema* a ser processado.
-     */
-    static getNonLocalFieldNames(schema) {
-        if (schema.fields) {
-            return schema.fields.reduce((fieldsAccumulator, currentField) => {
-                if (typeof currentField === 'string' || !currentField.local) {
-                    fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);
-                }
-                return fieldsAccumulator;
-            }, []);
-        }
-    }
-    /**
-     * Retorna o `id` referente ao registro do *schema* informado.
-     *
-     * @param {object} record Registro que será buscado o id.
-     * @param {PoSyncSchema} schema **Schema* a ser processado.
-     */
-    static getRecordId(record, schema) {
-        return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];
-    }
-    /**
-     * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.
-     *
-     * @param {PoSyncSchema} schema **Schema* a ser processado.
-     * @param {PoRequestType} requestType Tipo da requisição.
-     */
-    static getUrl(schema, requestType) {
-        return schema[`${requestType}UrlApi`];
-    }
-    /**
-     * Compara se dois objetos são iguais baseado na lista de campos.
-     *
-     * @param {Array<string>} fields Lista de campos a serem considerados na comparação.
-     * @param {any} model1 Objeto 1 a ser comparado.
-     * @param {any} model2 Objeto 2 a ser comparado.
-     */
-    static isModelsEqual(fields, model1, model2) {
-        if (fields) {
-            return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));
-        }
-    }
-    /**
-     * Retorna uma lista com dois objetos referentes ao registro informado.
-     * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.
-     *
-     * @param {PoSyncSchema} schema **Schema* do registro.
-     * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.
-     */
-    static separateSchemaFields(schema, record) {
-        const localFields = PoSchemaUtil.getLocalFieldNames(schema);
-        const localRecord = {};
-        const serverRecord = {};
-        Object.keys(record).forEach(field => {
-            if (localFields.includes(field)) {
-                localRecord[field] = record[field];
-            }
-            else {
-                serverRecord[field] = record[field];
-            }
-        });
-        return { serverRecord, localRecord };
-    }
-}
-/** Valor `default` para o campo `lastSync`. */
-PoSchemaUtil.defaultLastSync = new Date(-8640000000000000).toISOString();
-/** Nome da chave do identificador interno do sync. */
-PoSchemaUtil.syncInternalIdFieldName = 'SyncInternalId';
-/** Nome da chave no `storage` para os Schemas. */
-PoSchemaUtil.syncSchemasName = 'SyncSchemas';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-schema-util.model.js","sourceRoot":"","sources":["../../../../../../../projects/sync/src/lib/services/po-schema/po-schema-util/po-schema-util.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { PoRequestType } from '../../../models/po-request-type.enum';\r\nimport { PoSyncFieldOptions } from '../../po-sync/interfaces/po-sync-field-options.interface';\r\nimport { PoSyncSchema } from '../../po-sync/interfaces/po-sync-schema.interface';\r\n\r\n/**\r\n * @docsPrivate\r\n *\r\n * @description\r\n *\r\n * Serviço utilitário para operações no PoSyncSchema.\r\n */\r\nexport class PoSchemaUtil {\r\n  /** Valor `default` para o campo `lastSync`. */\r\n  public static readonly defaultLastSync: string = new Date(-8640000000000000).toISOString();\r\n\r\n  /** Nome da chave do identificador interno do sync. */\r\n  public static readonly syncInternalIdFieldName: string = 'SyncInternalId';\r\n\r\n  /** Nome da chave no `storage` para os Schemas. */\r\n  public static readonly syncSchemasName: string = 'SyncSchemas';\r\n\r\n  /**\r\n   * Verica se existem campos locais no *schema* informado.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   *\r\n   * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.\r\n   */\r\n  public static containsLocalFields(schema: PoSyncSchema): boolean {\r\n    if (schema.fields) {\r\n      return !!schema.fields.find(field => typeof field === 'object' && field.local);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna o valor atual do `lastSync` para determinado *schema*.\r\n   *\r\n   * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.\r\n   * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.\r\n   *\r\n   * @returns {string} Retorna uma *string* com o valor da última sincronização.\r\n   */\r\n  public static getLastSync(storageSchemas: Array<PoSyncSchema>, schemaName: string): string {\r\n    if (storageSchemas) {\r\n      const schemaFound = storageSchemas.find(schema => schema.name === schemaName);\r\n      return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;\r\n    }\r\n    return PoSchemaUtil.defaultLastSync;\r\n  }\r\n\r\n  /**\r\n   * Retorna a lista de campos locais definidos no *schema*.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getLocalFieldNames(schema: PoSyncSchema): Array<string> {\r\n    if (schema.fields) {\r\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\r\n        if (typeof currentField === 'object' && currentField.local) {\r\n          fieldsAccumulator.push(currentField.name);\r\n        }\r\n        return fieldsAccumulator;\r\n      }, []);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna a lista de campos não locais definidos no *schema*.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getNonLocalFieldNames(schema: PoSyncSchema): Array<string> {\r\n    if (schema.fields) {\r\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\r\n        if (typeof currentField === 'string' || !currentField.local) {\r\n          fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);\r\n        }\r\n        return fieldsAccumulator;\r\n      }, []);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna o `id` referente ao registro do *schema* informado.\r\n   *\r\n   * @param {object} record Registro que será buscado o id.\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getRecordId(record: object, schema: PoSyncSchema) {\r\n    return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];\r\n  }\r\n\r\n  /**\r\n   * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   * @param {PoRequestType} requestType Tipo da requisição.\r\n   */\r\n  public static getUrl(schema: PoSyncSchema, requestType: PoRequestType): string {\r\n    return schema[`${requestType}UrlApi`];\r\n  }\r\n\r\n  /**\r\n   * Compara se dois objetos são iguais baseado na lista de campos.\r\n   *\r\n   * @param {Array<string>} fields Lista de campos a serem considerados na comparação.\r\n   * @param {any} model1 Objeto 1 a ser comparado.\r\n   * @param {any} model2 Objeto 2 a ser comparado.\r\n   */\r\n  public static isModelsEqual(fields: Array<string>, model1: any, model2: any): boolean {\r\n    if (fields) {\r\n      return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna uma lista com dois objetos referentes ao registro informado.\r\n   * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* do registro.\r\n   * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.\r\n   */\r\n  public static separateSchemaFields(\r\n    schema: PoSyncSchema,\r\n    record: object\r\n  ): { serverRecord: object; localRecord: object } {\r\n    const localFields = PoSchemaUtil.getLocalFieldNames(schema);\r\n    const localRecord = {};\r\n    const serverRecord = {};\r\n\r\n    Object.keys(record).forEach(field => {\r\n      if (localFields.includes(field)) {\r\n        localRecord[field] = record[field];\r\n      } else {\r\n        serverRecord[field] = record[field];\r\n      }\r\n    });\r\n\r\n    return { serverRecord, localRecord };\r\n  }\r\n}\r\n"]}
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço utilitário para operações no PoSyncSchema.
+ */
+export class PoSchemaUtil {
+    /**
+     * Verica se existem campos locais no *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     *
+     * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.
+     */
+    static containsLocalFields(schema) {
+        if (schema.fields) {
+            return !!schema.fields.find(field => typeof field === 'object' && field.local);
+        }
+    }
+    /**
+     * Retorna o valor atual do `lastSync` para determinado *schema*.
+     *
+     * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.
+     * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.
+     *
+     * @returns {string} Retorna uma *string* com o valor da última sincronização.
+     */
+    static getLastSync(storageSchemas, schemaName) {
+        if (storageSchemas) {
+            const schemaFound = storageSchemas.find(schema => schema.name === schemaName);
+            return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;
+        }
+        return PoSchemaUtil.defaultLastSync;
+    }
+    /**
+     * Retorna a lista de campos locais definidos no *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getLocalFieldNames(schema) {
+        if (schema.fields) {
+            return schema.fields.reduce((fieldsAccumulator, currentField) => {
+                if (typeof currentField === 'object' && currentField.local) {
+                    fieldsAccumulator.push(currentField.name);
+                }
+                return fieldsAccumulator;
+            }, []);
+        }
+    }
+    /**
+     * Retorna a lista de campos não locais definidos no *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getNonLocalFieldNames(schema) {
+        if (schema.fields) {
+            return schema.fields.reduce((fieldsAccumulator, currentField) => {
+                if (typeof currentField === 'string' || !currentField.local) {
+                    fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);
+                }
+                return fieldsAccumulator;
+            }, []);
+        }
+    }
+    /**
+     * Retorna o `id` referente ao registro do *schema* informado.
+     *
+     * @param {object} record Registro que será buscado o id.
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getRecordId(record, schema) {
+        return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];
+    }
+    /**
+     * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     * @param {PoRequestType} requestType Tipo da requisição.
+     */
+    static getUrl(schema, requestType) {
+        return schema[`${requestType}UrlApi`];
+    }
+    /**
+     * Compara se dois objetos são iguais baseado na lista de campos.
+     *
+     * @param {Array<string>} fields Lista de campos a serem considerados na comparação.
+     * @param {any} model1 Objeto 1 a ser comparado.
+     * @param {any} model2 Objeto 2 a ser comparado.
+     */
+    static isModelsEqual(fields, model1, model2) {
+        if (fields) {
+            return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));
+        }
+    }
+    /**
+     * Retorna uma lista com dois objetos referentes ao registro informado.
+     * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.
+     *
+     * @param {PoSyncSchema} schema **Schema* do registro.
+     * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.
+     */
+    static separateSchemaFields(schema, record) {
+        const localFields = PoSchemaUtil.getLocalFieldNames(schema);
+        const localRecord = {};
+        const serverRecord = {};
+        Object.keys(record).forEach(field => {
+            if (localFields.includes(field)) {
+                localRecord[field] = record[field];
+            }
+            else {
+                serverRecord[field] = record[field];
+            }
+        });
+        return { serverRecord, localRecord };
+    }
+}
+/** Valor `default` para o campo `lastSync`. */
+PoSchemaUtil.defaultLastSync = new Date(-8640000000000000).toISOString();
+/** Nome da chave do identificador interno do sync. */
+PoSchemaUtil.syncInternalIdFieldName = 'SyncInternalId';
+/** Nome da chave no `storage` para os Schemas. */
+PoSchemaUtil.syncSchemasName = 'SyncSchemas';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-schema-util.model.js","sourceRoot":"","sources":["../../../../../../../projects/sync/src/lib/services/po-schema/po-schema-util/po-schema-util.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { PoRequestType } from '../../../models/po-request-type.enum';\nimport { PoSyncFieldOptions } from '../../po-sync/interfaces/po-sync-field-options.interface';\nimport { PoSyncSchema } from '../../po-sync/interfaces/po-sync-schema.interface';\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Serviço utilitário para operações no PoSyncSchema.\n */\nexport class PoSchemaUtil {\n  /** Valor `default` para o campo `lastSync`. */\n  public static readonly defaultLastSync: string = new Date(-8640000000000000).toISOString();\n\n  /** Nome da chave do identificador interno do sync. */\n  public static readonly syncInternalIdFieldName: string = 'SyncInternalId';\n\n  /** Nome da chave no `storage` para os Schemas. */\n  public static readonly syncSchemasName: string = 'SyncSchemas';\n\n  /**\n   * Verica se existem campos locais no *schema* informado.\n   *\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\n   *\n   * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.\n   */\n  public static containsLocalFields(schema: PoSyncSchema): boolean {\n    if (schema.fields) {\n      return !!schema.fields.find(field => typeof field === 'object' && field.local);\n    }\n  }\n\n  /**\n   * Retorna o valor atual do `lastSync` para determinado *schema*.\n   *\n   * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.\n   * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.\n   *\n   * @returns {string} Retorna uma *string* com o valor da última sincronização.\n   */\n  public static getLastSync(storageSchemas: Array<PoSyncSchema>, schemaName: string): string {\n    if (storageSchemas) {\n      const schemaFound = storageSchemas.find(schema => schema.name === schemaName);\n      return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;\n    }\n    return PoSchemaUtil.defaultLastSync;\n  }\n\n  /**\n   * Retorna a lista de campos locais definidos no *schema*.\n   *\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\n   */\n  public static getLocalFieldNames(schema: PoSyncSchema): Array<string> {\n    if (schema.fields) {\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\n        if (typeof currentField === 'object' && currentField.local) {\n          fieldsAccumulator.push(currentField.name);\n        }\n        return fieldsAccumulator;\n      }, []);\n    }\n  }\n\n  /**\n   * Retorna a lista de campos não locais definidos no *schema*.\n   *\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\n   */\n  public static getNonLocalFieldNames(schema: PoSyncSchema): Array<string> {\n    if (schema.fields) {\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\n        if (typeof currentField === 'string' || !currentField.local) {\n          fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);\n        }\n        return fieldsAccumulator;\n      }, []);\n    }\n  }\n\n  /**\n   * Retorna o `id` referente ao registro do *schema* informado.\n   *\n   * @param {object} record Registro que será buscado o id.\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\n   */\n  public static getRecordId(record: object, schema: PoSyncSchema) {\n    return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];\n  }\n\n  /**\n   * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.\n   *\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\n   * @param {PoRequestType} requestType Tipo da requisição.\n   */\n  public static getUrl(schema: PoSyncSchema, requestType: PoRequestType): string {\n    return schema[`${requestType}UrlApi`];\n  }\n\n  /**\n   * Compara se dois objetos são iguais baseado na lista de campos.\n   *\n   * @param {Array<string>} fields Lista de campos a serem considerados na comparação.\n   * @param {any} model1 Objeto 1 a ser comparado.\n   * @param {any} model2 Objeto 2 a ser comparado.\n   */\n  public static isModelsEqual(fields: Array<string>, model1: any, model2: any): boolean {\n    if (fields) {\n      return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));\n    }\n  }\n\n  /**\n   * Retorna uma lista com dois objetos referentes ao registro informado.\n   * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.\n   *\n   * @param {PoSyncSchema} schema **Schema* do registro.\n   * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.\n   */\n  public static separateSchemaFields(\n    schema: PoSyncSchema,\n    record: object\n  ): { serverRecord: object; localRecord: object } {\n    const localFields = PoSchemaUtil.getLocalFieldNames(schema);\n    const localRecord = {};\n    const serverRecord = {};\n\n    Object.keys(record).forEach(field => {\n      if (localFields.includes(field)) {\n        localRecord[field] = record[field];\n      } else {\n        serverRecord[field] = record[field];\n      }\n    });\n\n    return { serverRecord, localRecord };\n  }\n}\n"]}

package/esm2020/lib/services/po-schema/po-schema.service.mjs

@@ -0,0 +1,174 @@
+import { Injectable } from '@angular/core';
+import { PoSchemaUtil } from './po-schema-util/po-schema-util.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-schema-definition/po-schema-definition.service";
+import * as i2 from "@po-ui/ng-storage";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que realiza as operações nos `schemas`.
+ */
+export class PoSchemaService {
+    constructor(poSchemaDefinitionService, poStorage) {
+        this.poSchemaDefinitionService = poSchemaDefinitionService;
+        this.poStorage = poStorage;
+    }
+    /**
+     * Retorna o id a partir de uma chave de um *schema*.
+     *
+     * @param {string} schemaKey Chave do *schema* em que será realizada a busca do id.
+     */
+    static getIdByRecordKey(schemaKey) {
+        return schemaKey.split(':')[1];
+    }
+    /**
+     * Retorna a chave do *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     * @param {boolean} isLocalKey Indica se é uma chave local.
+     */
+    static getRecordKey(schemaName, recordId, isLocalKey = false) {
+        return isLocalKey ? `${schemaName}_local:${recordId}` : `${schemaName}:${recordId}`;
+    }
+    /**
+     * Verifica se o dado informado é uma chave de um *schema*.
+     *
+     * @param {string} data Dado que será verificado se é uma chave de um *schema*.
+     * @param {string} schemaName Nome do *schema*.
+     */
+    static isSchemaKey(data, schemaName) {
+        return data ? data.startsWith(`${schemaName}:`) : false;
+    }
+    /**
+     * Cria um novo registro para o *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* em que será criado o registro.
+     * @param {object} newRecord Registro que será criado.
+     */
+    async create(schema, newRecord) {
+        const id = PoSchemaUtil.getRecordId(newRecord, schema);
+        return this.save(schema, newRecord, id);
+    }
+    /**
+     * Destrói as chaves do *storage* que contém os registros dos *schemas*.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando as chaves referentes aos *schemas* forem destruídas.
+     */
+    async destroySchemasRecords() {
+        const schemas = await this.poSchemaDefinitionService.getAll();
+        const storageKeys = await this.poStorage.keys();
+        for (const key of storageKeys) {
+            const schemaKey = schemas.find(schema => PoSchemaService.isSchemaKey(key, schema.name));
+            if (schemaKey) {
+                const id = PoSchemaService.getIdByRecordKey(key);
+                await this.remove(schemaKey.name, id);
+            }
+        }
+    }
+    /**
+     * Retorna o registro referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    async get(schemaName, recordId) {
+        const isLocalRecord = true;
+        const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);
+        const record = await this.getRecord(schemaName, recordId);
+        return Object.assign(record, localRecord);
+    }
+    /**
+     * Retorna todos os registros referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     */
+    async getAll(schemaName) {
+        const storageKeys = await this.poStorage.keys();
+        const schemaRecords = [];
+        for (const key of storageKeys) {
+            if (PoSchemaService.isSchemaKey(key, schemaName)) {
+                const id = PoSchemaService.getIdByRecordKey(key);
+                schemaRecords.push(await this.get(schemaName, id));
+            }
+        }
+        return schemaRecords;
+    }
+    /**
+     * Aguarda a liberação do recurso limitado, posteriormente o envolve em um comportamento
+     * de bloqueio e desbloqueio.
+     *
+     * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.
+     */
+    limitedCallWrap(limitedResource) {
+        return this.poStorage.limitedCallWrap(limitedResource);
+    }
+    /**
+     * Remove um registro de um *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    async remove(schemaName, recordId) {
+        const recordKey = PoSchemaService.getRecordKey(schemaName, recordId);
+        const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);
+        await this.poStorage.remove(recordKey);
+        await this.poStorage.remove(localRecordKey);
+    }
+    /**
+     * Atualiza um registro de um *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente ao registro que será alterado.
+     * @param {object} record Registro que será atualizado.
+     * @param {any} recordId Id do registro que deseja ser alterado. Deve ser utilizado em casos em que o id foi alterado.
+     */
+    async update(schema, record, recordId) {
+        const id = PoSchemaUtil.getRecordId(record, schema);
+        if (recordId) {
+            record = await this.updateRecordId(schema.name, record, recordId);
+        }
+        return this.save(schema, record, id);
+    }
+    /**
+     * Atualiza todos os registros de um *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente aos registros que serão alterados.
+     * @param {Array<object>} records Lista de registros que serão alterados.
+     */
+    async updateAll(schema, records) {
+        for (const record of records) {
+            await this.update(schema, record);
+        }
+    }
+    async getRecord(schemaName, recordId, isLocalRecord = false) {
+        return (await this.poStorage.get(PoSchemaService.getRecordKey(schemaName, recordId, isLocalRecord))) || {};
+    }
+    async save(schema, record, recordId) {
+        const { serverRecord, localRecord } = PoSchemaUtil.separateSchemaFields(schema, record);
+        const recordKey = PoSchemaService.getRecordKey(schema.name, recordId);
+        await this.poStorage.set(recordKey, serverRecord);
+        await this.saveLocalFields(schema.name, localRecord, recordId);
+        return record;
+    }
+    async saveLocalFields(schemaName, localFields, recordId) {
+        const containsLocalFields = Object.keys(localFields).length;
+        if (containsLocalFields) {
+            const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);
+            await this.poStorage.set(localRecordKey, localFields);
+        }
+    }
+    async updateRecordId(schemaName, record, recordId) {
+        const isLocalRecord = true;
+        const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);
+        await this.remove(schemaName, recordId);
+        return Object.assign(record, localRecord);
+    }
+}
+PoSchemaService.ɵfac = function PoSchemaService_Factory(t) { return new (t || PoSchemaService)(i0.ɵɵinject(i1.PoSchemaDefinitionService), i0.ɵɵinject(i2.PoStorageService)); };
+PoSchemaService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoSchemaService, factory: PoSchemaService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoSchemaService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoSchemaDefinitionService }, { type: i2.PoStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-schema.service.js","sourceRoot":"","sources":["../../../../../../projects/sync/src/lib/services/po-schema/po-schema.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { PoStorageService } from '@po-ui/ng-storage';\n\nimport { PoSchemaDefinitionService } from './po-schema-definition/po-schema-definition.service';\nimport { PoSchemaUtil } from './po-schema-util/po-schema-util.model';\nimport { PoSyncSchema } from '../po-sync/interfaces/po-sync-schema.interface';\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Serviço que realiza as operações nos `schemas`.\n */\n@Injectable()\nexport class PoSchemaService {\n  constructor(private poSchemaDefinitionService: PoSchemaDefinitionService, private poStorage: PoStorageService) {}\n\n  /**\n   * Retorna o id a partir de uma chave de um *schema*.\n   *\n   * @param {string} schemaKey Chave do *schema* em que será realizada a busca do id.\n   */\n  private static getIdByRecordKey(schemaKey: string): string {\n    return schemaKey.split(':')[1];\n  }\n\n  /**\n   * Retorna a chave do *schema* informado.\n   *\n   * @param {string} schemaName Nome do *schema*.\n   * @param {any} recordId Id do registro.\n   * @param {boolean} isLocalKey Indica se é uma chave local.\n   */\n  private static getRecordKey(schemaName: string, recordId: any, isLocalKey: boolean = false): string {\n    return isLocalKey ? `${schemaName}_local:${recordId}` : `${schemaName}:${recordId}`;\n  }\n\n  /**\n   * Verifica se o dado informado é uma chave de um *schema*.\n   *\n   * @param {string} data Dado que será verificado se é uma chave de um *schema*.\n   * @param {string} schemaName Nome do *schema*.\n   */\n  private static isSchemaKey(data: string, schemaName: string): boolean {\n    return data ? data.startsWith(`${schemaName}:`) : false;\n  }\n\n  /**\n   * Cria um novo registro para o *schema* informado.\n   *\n   * @param {PoSyncSchema} schema **Schema* em que será criado o registro.\n   * @param {object} newRecord Registro que será criado.\n   */\n  async create(schema: PoSyncSchema, newRecord: object): Promise<object> {\n    const id = PoSchemaUtil.getRecordId(newRecord, schema);\n    return this.save(schema, newRecord, id);\n  }\n\n  /**\n   * Destrói as chaves do *storage* que contém os registros dos *schemas*.\n   *\n   * @returns {Promise<void>} Promessa que é resolvida quando as chaves referentes aos *schemas* forem destruídas.\n   */\n  async destroySchemasRecords(): Promise<void> {\n    const schemas = await this.poSchemaDefinitionService.getAll();\n    const storageKeys = await this.poStorage.keys();\n\n    for (const key of storageKeys) {\n      const schemaKey = schemas.find(schema => PoSchemaService.isSchemaKey(key, schema.name));\n\n      if (schemaKey) {\n        const id = PoSchemaService.getIdByRecordKey(key);\n        await this.remove(schemaKey.name, id);\n      }\n    }\n  }\n\n  /**\n   * Retorna o registro referente ao *schema* informado.\n   *\n   * @param {string} schemaName Nome do *schema*.\n   * @param {any} recordId Id do registro.\n   */\n  async get(schemaName: string, recordId: any): Promise<object> {\n    const isLocalRecord = true;\n    const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);\n    const record = await this.getRecord(schemaName, recordId);\n\n    return Object.assign(record, localRecord);\n  }\n\n  /**\n   * Retorna todos os registros referente ao *schema* informado.\n   *\n   * @param {string} schemaName Nome do *schema*.\n   */\n  async getAll(schemaName: string): Promise<Array<object>> {\n    const storageKeys = await this.poStorage.keys();\n    const schemaRecords = [];\n\n    for (const key of storageKeys) {\n      if (PoSchemaService.isSchemaKey(key, schemaName)) {\n        const id = PoSchemaService.getIdByRecordKey(key);\n        schemaRecords.push(await this.get(schemaName, id));\n      }\n    }\n\n    return schemaRecords;\n  }\n\n  /**\n   * Aguarda a liberação do recurso limitado, posteriormente o envolve em um comportamento\n   * de bloqueio e desbloqueio.\n   *\n   * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.\n   */\n  limitedCallWrap(limitedResource: Function): Promise<any> {\n    return this.poStorage.limitedCallWrap(limitedResource);\n  }\n\n  /**\n   * Remove um registro de um *schema* informado.\n   *\n   * @param {string} schemaName Nome do *schema*.\n   * @param {any} recordId Id do registro.\n   */\n  async remove(schemaName: string, recordId: any): Promise<any> {\n    const recordKey = PoSchemaService.getRecordKey(schemaName, recordId);\n    const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);\n\n    await this.poStorage.remove(recordKey);\n    await this.poStorage.remove(localRecordKey);\n  }\n\n  /**\n   * Atualiza um registro de um *schema* informado.\n   *\n   * @param {PoSyncSchema} schema **Schema* referente ao registro que será alterado.\n   * @param {object} record Registro que será atualizado.\n   * @param {any} recordId Id do registro que deseja ser alterado. Deve ser utilizado em casos em que o id foi alterado.\n   */\n  async update(schema: PoSyncSchema, record: object, recordId?: any): Promise<object> {\n    const id = PoSchemaUtil.getRecordId(record, schema);\n\n    if (recordId) {\n      record = await this.updateRecordId(schema.name, record, recordId);\n    }\n\n    return this.save(schema, record, id);\n  }\n\n  /**\n   * Atualiza todos os registros de um *schema*.\n   *\n   * @param {PoSyncSchema} schema **Schema* referente aos registros que serão alterados.\n   * @param {Array<object>} records Lista de registros que serão alterados.\n   */\n  async updateAll(schema: PoSyncSchema, records: Array<object>): Promise<void> {\n    for (const record of records) {\n      await this.update(schema, record);\n    }\n  }\n\n  private async getRecord(schemaName, recordId, isLocalRecord = false): Promise<object> {\n    return (await this.poStorage.get(PoSchemaService.getRecordKey(schemaName, recordId, isLocalRecord))) || {};\n  }\n\n  private async save(schema: PoSyncSchema, record: object, recordId: any) {\n    const { serverRecord, localRecord } = PoSchemaUtil.separateSchemaFields(schema, record);\n    const recordKey = PoSchemaService.getRecordKey(schema.name, recordId);\n\n    await this.poStorage.set(recordKey, serverRecord);\n    await this.saveLocalFields(schema.name, localRecord, recordId);\n\n    return record;\n  }\n\n  private async saveLocalFields(schemaName: string, localFields: object, recordId): Promise<void> {\n    const containsLocalFields = Object.keys(localFields).length;\n\n    if (containsLocalFields) {\n      const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);\n      await this.poStorage.set(localRecordKey, localFields);\n    }\n  }\n\n  private async updateRecordId(schemaName, record, recordId) {\n    const isLocalRecord = true;\n\n    const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);\n    await this.remove(schemaName, recordId);\n\n    return Object.assign(record, localRecord);\n  }\n}\n"]}

package/esm2020/lib/services/po-sync/interfaces/po-sync-config.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1jb25maWcuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc3luYy9zcmMvbGliL3NlcnZpY2VzL3BvLXN5bmMvaW50ZXJmYWNlcy9wby1zeW5jLWNvbmZpZy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvRGF0YVRyYW5zZm9ybSB9IGZyb20gJy4vLi4vLi4vLi4vbW9kZWxzL3BvLWRhdGEtdHJhbnNmb3JtLm1vZGVsJztcbmltcG9ydCB7IFBvTmV0d29ya1R5cGUgfSBmcm9tICcuLy4uLy4uLy4uL21vZGVscy9wby1uZXR3b3JrLXR5cGUuZW51bSc7XG5cbi8qKlxuICogQHVzZWRCeSBQb1N5bmNTZXJ2aWNlXG4gKlxuICogQGRlc2NyaXB0aW9uXG4gKlxuICogSW50ZXJmYWNlIHBhcmEgYSBkZWZpbmnDp8OjbyBkYXMgY29uZmlndXJhw6fDtWVzIGRvIHNpbmNyb25pc21vLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgUG9TeW5jQ29uZmlnIHtcbiAgLyoqXG4gICAqIENsYXNzZSB1c2FkYSBwYXJhIGEgdHJhc2Zvcm1hw6fDo28gZG9zIGRhZG9zIG5hcyByZXF1aXNpw6fDtWVzLlxuICAgKlxuICAgKiA+IFZlamEgbWFpcyBkZXRhbGhlcyBlbSBbRnVuZGFtZW50b3MgZG8gUE8gU3luYyAtIEFkYXB0YW5kbyBhIHJlc3Bvc3RhIGRhIEFQSSBwYXJhIG8gcGFkcsOjbyBkbyBQTyBVSV0oL2d1aWRlcy9zeW5jLWZ1bmRhbWVudGFscykuXG4gICAqL1xuICBkYXRhVHJhbnNmb3JtPzogUG9EYXRhVHJhbnNmb3JtO1xuXG4gIC8qKlxuICAgKiBUZW1wbyBlbSBzZWd1bmRvcyBkbyBzaWNyb25pc21vIHBlcmnDs2RpY28uXG4gICAqIENhc28gbsOjbyBzZWphIGRlZmluaWRvLCBvIHNpbmNyb25pc21vIHBlcmnDs2RpY28gZXN0YXLDoSBkZXNhYmlsaXRhZG8uXG4gICAqL1xuICBwZXJpb2Q/OiBudW1iZXI7XG5cbiAgLyoqIFRpcG9zIGRlIGNvbmV4w7VlcyBwZXJtaXRpZGFzIHBhcmEgbyBzaW5jcm9uaXNtby4gKi9cbiAgdHlwZTogUG9OZXR3b3JrVHlwZSB8IEFycmF5PFBvTmV0d29ya1R5cGU+O1xufVxuIl19

package/esm2020/lib/services/po-sync/interfaces/po-sync-field-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1maWVsZC1vcHRpb25zLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL2xpYi9zZXJ2aWNlcy9wby1zeW5jL2ludGVyZmFjZXMvcG8tc3luYy1maWVsZC1vcHRpb25zLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAdXNlZEJ5IFBvU3luY1NlcnZpY2VcbiAqXG4gKiBAZGVzY3JpcHRpb25cbiAqXG4gKiBJbnRlcmZhY2UgcXVlIGlyw6EgbWFwZWFyIGFzIGNvbmZpZ3VyYcOnw7VlcyBkb3MgY2FtcG9zIGRvIGBQb1N5bmNTY2hlbWFgLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBvU3luY0ZpZWxkT3B0aW9ucyB7XG4gIC8qKiBQcm9wcmllZGFkZSBxdWUgaW5mb3JtYSBvIG5vbWUgZG8gY2FtcG8uICovXG4gIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcblxuICAvKiogUHJvcHJpZWRhZGUgcXVlIGluZm9ybWEgc2UgbyBjYW1wbyBzZXLDoSBhcGVuYXMgcGFyYSBhcm1hemVuYW1lbnRvIGxvY2FsXG4gICAqIG91IHNlIGRldmUgc2VyIGVudmlhZG8gcGFyYSBvIHNlcnZpZG9yLlxuICAgKi9cbiAgcmVhZG9ubHkgbG9jYWw/OiBib29sZWFuO1xufVxuIl19

package/esm2020/lib/services/po-sync/interfaces/po-sync-response.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1yZXNwb25zZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zeW5jL3NyYy9saWIvc2VydmljZXMvcG8tc3luYy9pbnRlcmZhY2VzL3BvLXN5bmMtcmVzcG9uc2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwRXJyb3JSZXNwb25zZSwgSHR0cFJlc3BvbnNlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuXG5pbXBvcnQgeyBQb0V2ZW50U291cmNpbmdFcnJvclJlc3BvbnNlIH0gZnJvbSAnLi4vLi4vLi4vbW9kZWxzL3BvLWV2ZW50LXNvdXJjaW5nLWVycm9yLXJlc3BvbnNlLm1vZGVsJztcbmltcG9ydCB7IFBvSHR0cFJlcXVlc3REYXRhIH0gZnJvbSAnLi4vLi4vcG8taHR0cC1jbGllbnQvaW50ZXJmYWNlcy9wby1odHRwLXJlcXVlc3QtZGF0YS5pbnRlcmZhY2UnO1xuXG4vKipcbiAqIEB1c2VkQnkgUG9TeW5jU2VydmljZVxuICpcbiAqIEBkZXNjcmlwdGlvblxuICpcbiAqIERlZmluZSBhIHJlc3Bvc3RhIGRvcyBldmVudG9zIGVudmlhZG9zIGFvIHNlcnZpZG9yLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBvU3luY1Jlc3BvbnNlIHtcbiAgLyoqIElkZW50aWZpY2Fkb3IgZG8gZXZlbnRvIG5hIGZpbGEuICovXG4gIGlkOiBudW1iZXI7XG5cbiAgLyoqIElkZW50aWZpY2Fkb3IgY3VzdG9taXphZG8gZG8gcmVnaXN0cm8uICovXG4gIGN1c3RvbVJlcXVlc3RJZD86IHN0cmluZztcblxuICAvKiogRGFkb3MgZGEgcmVxdWlzacOnw6NvLiAqL1xuICByZXF1ZXN0OiBQb0h0dHBSZXF1ZXN0RGF0YTtcblxuICAvKiogUmVzcG9zdGEgcmV0b3JuYWRhIGFww7NzIGEgdGVudGF0aXZhIGRlIGVudmlvIHBhcmEgbyBzZXJ2aWRvci4gKi9cbiAgcmVzcG9uc2U6IEh0dHBSZXNwb25zZTxPYmplY3Q+IHwgSHR0cEVycm9yUmVzcG9uc2UgfCBQb0V2ZW50U291cmNpbmdFcnJvclJlc3BvbnNlO1xufVxuIl19

package/esm2020/lib/services/po-sync/interfaces/po-sync-schema.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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