@po-ui/ng-sync 15.15.0 → 16.0.0-next.2

package/esm2022/lib/services/po-event-sourcing/po-event-sourcing.service.mjs

@@ -0,0 +1,379 @@
+import { Injectable } from '@angular/core';
+import { StatusCodes } from 'http-status-codes';
+import { Observable, of, Subject } from 'rxjs';
+import { expand, map, reduce } from 'rxjs/operators';
+import { toBase64, toFile } from '../../utils/utils';
+import { PoEventSourcingErrorResponse } from '../../models/po-event-sourcing-error-response.model';
+import { PoEventSourcingOperation } from './enums/po-event-sourcing-operation.enum';
+import { PoHttpRequestType } from '../po-http-client/po-http-request-type.enum';
+import { PoRequestType } from '../../models/po-request-type.enum';
+import { PoSchemaUtil } from './../po-schema/po-schema-util/po-schema-util.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./../po-schema/po-schema-definition/po-schema-definition.service";
+import * as i2 from "./../po-schema/po-schema.service";
+import * as i3 from "@po-ui/ng-storage";
+import * as i4 from "./../po-http-client/po-http-client.service";
+export class PoEventSourcingService {
+    poSchemaDefinition;
+    poSchemaService;
+    poStorage;
+    poHttpClient;
+    static event_sourcing_name = 'EventSourcing';
+    static VALID_HTTP_STATUS_CODES = [
+        StatusCodes.OK,
+        StatusCodes.CREATED,
+        StatusCodes.ACCEPTED,
+        StatusCodes.NON_AUTHORITATIVE_INFORMATION,
+        StatusCodes.NO_CONTENT,
+        StatusCodes.RESET_CONTENT,
+        StatusCodes.PARTIAL_CONTENT,
+        StatusCodes.MULTI_STATUS // 207
+    ];
+    config;
+    stoppedQueueEventSourcing = false;
+    emitter;
+    eventSub;
+    responseSubject = new Subject();
+    schemasSyncConfig = {};
+    constructor(poSchemaDefinition, poSchemaService, poStorage, poHttpClient) {
+        this.poSchemaDefinition = poSchemaDefinition;
+        this.poSchemaService = poSchemaService;
+        this.poStorage = poStorage;
+        this.poHttpClient = poHttpClient;
+    }
+    static getUrl(eventSourcingItem, schema, requestType) {
+        const schemaUrl = PoSchemaUtil.getUrl(schema, requestType);
+        const schemaId = eventSourcingItem.record[schema.idField];
+        if (requestType === PoRequestType.GET) {
+            return schemaUrl;
+        }
+        if ([PoRequestType.DELETE, PoRequestType.PATCH].includes(requestType)) {
+            return schemaUrl ? `${schemaUrl}/${schemaId}` : `${PoSchemaUtil.getUrl(schema, PoRequestType.GET)}/${schemaId}`;
+        }
+        if (requestType === PoRequestType.POST) {
+            return schemaUrl ? schemaUrl : PoSchemaUtil.getUrl(schema, PoRequestType.GET);
+        }
+    }
+    create(schemaName, newItem, customRequestId) {
+        const eventSourcingItem = this.createEventSourcingItem(PoEventSourcingOperation.Insert, newItem, schemaName, customRequestId);
+        return this.insertEventSourcingQueue(eventSourcingItem);
+    }
+    async createBatchEvents(schemaName, eventList) {
+        const eventSourcingList = this.createEventSourcingList(schemaName, eventList);
+        await this.poStorage.appendArrayToArray(PoEventSourcingService.event_sourcing_name, eventSourcingList);
+        this.notifyEventCreation();
+    }
+    /**
+     * Destrói a chave do *storage* que contém a fila de dados que estão esperando para serem enviados ao
+     * servidor *(EventSourcing)*.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando a chave referente a fila de *EventSourcing* for destruída.
+     */
+    destroyEventSourcingQueue() {
+        return this.poStorage.remove(PoEventSourcingService.event_sourcing_name);
+    }
+    async httpCommand(httpOperationData, customRequestId) {
+        httpOperationData = await this.serializeBody(httpOperationData);
+        const eventSourcingItem = this.createEventSourcingItem(PoEventSourcingOperation.Http, httpOperationData, undefined, customRequestId);
+        await this.insertEventSourcingQueue(eventSourcingItem);
+        return eventSourcingItem.id;
+    }
+    responsesSubject() {
+        return this.responseSubject.asObservable();
+    }
+    onSaveData() {
+        if (!this.eventSub) {
+            this.eventSub = Observable.create(subscriber => (this.emitter = subscriber));
+        }
+        return this.eventSub;
+    }
+    remove(schemaName, itemToDelete, customRequestId) {
+        const eventSourcingItem = this.createEventSourcingItem(PoEventSourcingOperation.Delete, itemToDelete, schemaName, customRequestId);
+        return this.insertEventSourcingQueue(eventSourcingItem);
+    }
+    removeEventSourcingItem(idEventSourcingItem) {
+        return this.poStorage.removeItemFromArray(PoEventSourcingService.event_sourcing_name, 'id', idEventSourcingItem);
+    }
+    syncGet() {
+        const syncGetFunction = async () => this.poSchemaDefinition.getAll().then(schemas => {
+            const schemaPromises = this.updateStorageSchemas(schemas);
+            return Promise.all(schemaPromises);
+        });
+        return this.poSchemaService.limitedCallWrap(syncGetFunction);
+    }
+    async syncSend() {
+        const syncSendFunction = async () => {
+            const itemOfQueue = await this.poStorage.getFirstItem(PoEventSourcingService.event_sourcing_name);
+            if (itemOfQueue) {
+                await this.selectOperation(itemOfQueue);
+            }
+            if (this.stoppedQueueEventSourcing || !itemOfQueue) {
+                this.stoppedQueueEventSourcing = false;
+                return Promise.resolve();
+            }
+            return syncSendFunction();
+        };
+        return this.poSchemaService.limitedCallWrap(syncSendFunction);
+    }
+    update(schemaName, itemUpdated, customRequestId) {
+        const eventSourcingItem = this.createEventSourcingItem(PoEventSourcingOperation.Update, itemUpdated, schemaName, customRequestId);
+        return this.insertEventSourcingQueue(eventSourcingItem);
+    }
+    /* Avalia se o body é do tipo File e se for converte para base64 */
+    async serializeBody(requestData) {
+        let { body, mimeType, bodyType, fileName } = requestData;
+        if (body instanceof File) {
+            bodyType = 'File';
+            mimeType = body.type;
+            fileName = body.name;
+            body = await toBase64(body);
+        }
+        return { ...requestData, body, mimeType, bodyType, fileName };
+    }
+    buildUrlParams(schema, baseUrl, pageNumber) {
+        const params = [];
+        params.push(`${this.config.dataTransform.getPageSizeParamName()}=${schema.pageSize}`);
+        params.push(`${this.config.dataTransform.getPageParamName()}=${pageNumber}`);
+        return `${baseUrl}?${params.join('&')}`;
+    }
+    checkRecordIdExists(recordId, operation) {
+        if (!recordId) {
+            const error = {
+                message: 'Identifier not defined',
+                operation: operation
+            };
+            throw new PoEventSourcingErrorResponse(error);
+        }
+    }
+    concatPageItems(pageAcumulator, requestBody) {
+        if (requestBody[this.config.dataTransform.getItemsFieldName()]) {
+            pageAcumulator.data = [...pageAcumulator.data, ...requestBody[this.config.dataTransform.getItemsFieldName()]];
+        }
+        return pageAcumulator;
+    }
+    createEventSourcingItem(operation, newItem, schemaName, customRequestId, id) {
+        if (!schemaName && operation !== PoEventSourcingOperation.Http) {
+            throw new Error('PoSyncSchema is not defined.');
+        }
+        return {
+            id: id ? id : new Date().getTime(),
+            dateTime: new Date().getTime(),
+            schema: schemaName,
+            operation: operation,
+            record: newItem,
+            customRequestId: customRequestId
+        };
+    }
+    createEventSourcingList(schemaName, eventList) {
+        return eventList.map((eventItem, index) => {
+            const id = new Date().getTime() + index;
+            return this.createEventSourcingItem(eventItem.operation, eventItem.record, schemaName, eventItem.customRequestId, id);
+        });
+    }
+    createSchemaSyncConfig(schemaName) {
+        this.schemasSyncConfig[schemaName] = {
+            page: undefined,
+            currentUrlDiff: undefined,
+            responseDate: undefined
+        };
+    }
+    async deleteOperation(eventSourcingItem) {
+        try {
+            const schema = await this.poSchemaDefinition.get(eventSourcingItem.schema);
+            const recordId = eventSourcingItem.record[schema.idField];
+            this.checkRecordIdExists(recordId, PoEventSourcingOperation.Delete);
+            const url = PoEventSourcingService.getUrl(eventSourcingItem, schema, PoRequestType.DELETE);
+            const response = await this.sendServerItem(url, PoHttpRequestType.DELETE);
+            await this.removeEventSourcingValidItem(response.status, eventSourcingItem);
+            return await this.sendResponseSubject(eventSourcingItem, response);
+        }
+        catch (errorResponse) {
+            return this.sendResponseSubject(eventSourcingItem, errorResponse, true);
+        }
+    }
+    diffServerItems(currentUrlDiff) {
+        return this.poHttpClient.get(currentUrlDiff);
+    }
+    getBodyAndDate(schemaName, response) {
+        const getDateFieldName = this.config.dataTransform.getDateFieldName();
+        const responseSyncDate = response.body[getDateFieldName];
+        this.schemasSyncConfig[schemaName]['responseDate'] = responseSyncDate;
+        return response.body;
+    }
+    async getServerDiffRecords(schema, baseUrl) {
+        const initialAcumulatorPage = { entity: schema.name, data: [] };
+        const diffUrl = this.schemasSyncConfig[schema.name]['currentUrlDiff'];
+        const serverResponse = await this.diffServerItems(diffUrl)
+            .pipe(map(response => this.getBodyAndDate(schema.name, response)), expand(data => this.paginateSchemaData(data, schema, baseUrl)), reduce((pageAcumulator, requestBody) => this.concatPageItems(pageAcumulator, requestBody), initialAcumulatorPage))
+            .toPromise();
+        return serverResponse.data;
+    }
+    async httpOperation(eventSourcingItem) {
+        try {
+            const requestData = await this.createPoHttpRequestData(eventSourcingItem.record.url, eventSourcingItem.record.method, eventSourcingItem.record, eventSourcingItem.record.headers);
+            const response = await this.poHttpClient.createRequest(requestData).toPromise();
+            const poHttpCommandResponse = {
+                id: eventSourcingItem.id,
+                customRequestId: eventSourcingItem.customRequestId,
+                request: eventSourcingItem.record,
+                response: response
+            };
+            this.responseSubject.next(poHttpCommandResponse);
+            return this.removeEventSourcingValidItem(response.status, eventSourcingItem);
+        }
+        catch (errorHttpClient) {
+            return this.sendResponseSubject(eventSourcingItem, errorHttpClient, true);
+        }
+    }
+    async insertEventSourcingQueue(eventSourcingItem) {
+        const eventSourcingUpdatedQueue = await this.poStorage.appendItemToArray(PoEventSourcingService.event_sourcing_name, eventSourcingItem);
+        this.notifyEventCreation();
+        return Promise.resolve(eventSourcingUpdatedQueue);
+    }
+    async insertOperation(currentEventSourcingItem) {
+        const schema = await this.poSchemaDefinition.get(currentEventSourcingItem.schema);
+        const url = PoEventSourcingService.getUrl(currentEventSourcingItem, schema, PoRequestType.POST);
+        try {
+            const response = await this.sendServerItem(url, PoHttpRequestType.POST, currentEventSourcingItem.record);
+            const recordUpdatedByServer = response.body;
+            await this.removeEventSourcingValidItem(response.status, currentEventSourcingItem);
+            const id = currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName];
+            await this.poSchemaService.update(schema, recordUpdatedByServer, id);
+            const eventSourcingItems = await this.poStorage.get(PoEventSourcingService.event_sourcing_name);
+            await this.updatePendingEventSourcing(currentEventSourcingItem, schema.idField, recordUpdatedByServer, eventSourcingItems);
+            return this.sendResponseSubject(currentEventSourcingItem, response);
+        }
+        catch (errorHttpClient) {
+            return this.sendResponseSubject(currentEventSourcingItem, errorHttpClient, true);
+        }
+    }
+    isValidStatus(status) {
+        return PoEventSourcingService.VALID_HTTP_STATUS_CODES.includes(status);
+    }
+    notifyEventCreation() {
+        if (this.emitter) {
+            this.emitter.next();
+        }
+    }
+    paginateSchemaData(data, schema, baseUrl) {
+        this.config.dataTransform.transform(data);
+        if (this.config.dataTransform.hasNext()) {
+            this.schemasSyncConfig[schema.name]['currentUrlDiff'] = this.buildUrlParams(schema, baseUrl, ++this.schemasSyncConfig[schema.name]['page']);
+            return this.diffServerItems(this.schemasSyncConfig[schema.name]['currentUrlDiff']).pipe(map(response => this.getBodyAndDate(schema.name, response)));
+        }
+        return of();
+    }
+    removeEventSourcingValidItem(status, eventSourcingItem) {
+        if (this.isValidStatus(status) || eventSourcingItem.operation === PoEventSourcingOperation.Http) {
+            return this.removeEventSourcingItem(eventSourcingItem.id);
+        }
+    }
+    selectOperation(eventSourcingItem) {
+        switch (eventSourcingItem.operation) {
+            case PoEventSourcingOperation.Insert:
+                return this.insertOperation(eventSourcingItem);
+            case PoEventSourcingOperation.Update:
+                return this.updateOperation(eventSourcingItem);
+            case PoEventSourcingOperation.Delete:
+                return this.deleteOperation(eventSourcingItem);
+            case PoEventSourcingOperation.Http:
+                return this.httpOperation(eventSourcingItem);
+        }
+    }
+    sendResponseSubject(eventSourcingItem, response, isSubjectError = false) {
+        const poSyncResponse = {
+            id: eventSourcingItem.id,
+            customRequestId: eventSourcingItem.customRequestId,
+            request: eventSourcingItem.record,
+            response: response
+        };
+        this.stoppedQueueEventSourcing = isSubjectError;
+        this.responseSubject.next(poSyncResponse);
+        return Promise.resolve();
+    }
+    async sendServerItem(url, method, body) {
+        const requestData = await this.createPoHttpRequestData(url, method, body);
+        return this.poHttpClient.createRequest(requestData).toPromise();
+    }
+    async createPoHttpRequestData(url, method, record, headers) {
+        let body = record.body ?? record;
+        if (record.bodyType === 'File') {
+            body = await this.createFormData(body, record.fileName, record.mimeType, record.formField);
+        }
+        return { url, method, body, headers };
+    }
+    async createFormData(body, fileName, mimeType, formField = 'file') {
+        const file = await toFile(body, fileName, mimeType);
+        const formData = new FormData();
+        formData.append(formField, file, fileName);
+        return formData;
+    }
+    async updateOperation(eventSourcingItem) {
+        const schema = await this.poSchemaDefinition.get(eventSourcingItem.schema);
+        const url = PoEventSourcingService.getUrl(eventSourcingItem, schema, PoRequestType.PATCH);
+        try {
+            const recordId = eventSourcingItem.record[schema.idField];
+            this.checkRecordIdExists(recordId, PoEventSourcingOperation.Update);
+            const response = await this.sendServerItem(url, PoHttpRequestType.PUT, eventSourcingItem.record);
+            await this.removeEventSourcingValidItem(response.status, eventSourcingItem);
+            return await this.sendResponseSubject(eventSourcingItem, response);
+        }
+        catch (errorHttpClient) {
+            return this.sendResponseSubject(eventSourcingItem, errorHttpClient, true);
+        }
+    }
+    updatePendingEventSourcing(currentEventSourcingItem, idFieldSchema, inserted, eventSourcingItems) {
+        if (currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName]) {
+            eventSourcingItems.forEach((eventSourcingItem, position) => {
+                const isCurrentEventSourcingItem = !eventSourcingItem.record[idFieldSchema] &&
+                    eventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName] ===
+                        currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName];
+                if (isCurrentEventSourcingItem) {
+                    eventSourcingItems[position].record[idFieldSchema] = inserted[idFieldSchema];
+                }
+            });
+            return this.poStorage.set(PoEventSourcingService.event_sourcing_name, eventSourcingItems);
+        }
+        else {
+            return Promise.resolve();
+        }
+    }
+    async updateRecords(serverRecords, schema) {
+        for (const serverRecord of serverRecords) {
+            await this.updateRecordByServerRecord(serverRecord, schema);
+        }
+    }
+    async updateRecordByServerRecord(serverRecord, schema) {
+        const recordId = serverRecord[schema.idField];
+        const storageRecord = await this.poSchemaService.get(schema.name, recordId);
+        const existsStorageRecord = !!Object.keys(storageRecord).length;
+        if (existsStorageRecord && serverRecord[schema.deletedField]) {
+            return await this.poSchemaService.remove(schema.name, serverRecord[schema.idField]);
+        }
+        if (existsStorageRecord && !serverRecord[schema.deletedField]) {
+            return await this.poSchemaService.update(schema, serverRecord);
+        }
+        if (!existsStorageRecord && !serverRecord[schema.deletedField]) {
+            return await this.poSchemaService.create(schema, serverRecord);
+        }
+    }
+    async updateStorageBySchema(schema) {
+        this.createSchemaSyncConfig(schema.name);
+        this.schemasSyncConfig[schema.name]['page'] = 1;
+        const baseUrl = `${PoSchemaUtil.getUrl(schema, PoRequestType.DIFF)}/${schema.lastSync}`;
+        this.schemasSyncConfig[schema.name]['currentUrlDiff'] = this.buildUrlParams(schema, baseUrl, this.schemasSyncConfig[schema.name]['page']);
+        const serverRecords = await this.getServerDiffRecords(schema, baseUrl);
+        await this.updateRecords(serverRecords, schema);
+        schema.lastSync = this.schemasSyncConfig[schema.name]['responseDate'];
+        await this.poSchemaDefinition.update(schema);
+    }
+    updateStorageSchemas(schemas) {
+        return schemas.map((schema) => this.updateStorageBySchema(schema));
+    }
+    static ɵfac = function PoEventSourcingService_Factory(t) { return new (t || PoEventSourcingService)(i0.ɵɵinject(i1.PoSchemaDefinitionService), i0.ɵɵinject(i2.PoSchemaService), i0.ɵɵinject(i3.PoStorageService), i0.ɵɵinject(i4.PoHttpClientService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoEventSourcingService, factory: PoEventSourcingService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoEventSourcingService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoSchemaDefinitionService }, { type: i2.PoSchemaService }, { type: i3.PoStorageService }, { type: i4.PoHttpClientService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-event-sourcing.service.js","sourceRoot":"","sources":["../../../../../../projects/sync/src/lib/services/po-event-sourcing/po-event-sourcing.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpResponse, HttpErrorResponse } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\n\r\nimport { StatusCodes } from 'http-status-codes';\r\nimport { Observable, of, Subject } from 'rxjs';\r\nimport { expand, map, reduce } from 'rxjs/operators';\r\n\r\nimport { PoStorageService } from '@po-ui/ng-storage';\r\n\r\nimport { toBase64, toFile } from '../../utils/utils';\r\n\r\nimport { PoEventSourcingErrorResponse } from '../../models/po-event-sourcing-error-response.model';\r\nimport { PoEventSourcingItem } from './interfaces/po-event-sourcing-item.interface';\r\nimport { PoEventSourcingOperation } from './enums/po-event-sourcing-operation.enum';\r\nimport { PoEventSourcingSummaryItem } from './interfaces/po-event-sourcing-summary-item.interface';\r\nimport { PoHttpHeaderOption } from './../po-http-client/interfaces/po-http-header-option.interface';\r\nimport { PoHttpClientService } from './../po-http-client/po-http-client.service';\r\nimport { PoHttpRequestData } from '../po-http-client/interfaces/po-http-request-data.interface';\r\nimport { PoHttpRequestType } from '../po-http-client/po-http-request-type.enum';\r\nimport { PoRequestType } from '../../models/po-request-type.enum';\r\nimport { PoSchemaDefinitionService } from './../po-schema/po-schema-definition/po-schema-definition.service';\r\nimport { PoSchemaService } from './../po-schema/po-schema.service';\r\nimport { PoSchemaUtil } from './../po-schema/po-schema-util/po-schema-util.model';\r\nimport { PoSyncConfig } from '../po-sync/interfaces/po-sync-config.interface';\r\nimport { PoSyncResponse } from '../po-sync/interfaces/po-sync-response.interface';\r\nimport { PoSyncSchema } from './../po-sync/interfaces/po-sync-schema.interface';\r\n\r\n@Injectable()\r\nexport class PoEventSourcingService {\r\n  static readonly event_sourcing_name: string = 'EventSourcing';\r\n\r\n  private static readonly VALID_HTTP_STATUS_CODES = [\r\n    StatusCodes.OK, // 200\r\n    StatusCodes.CREATED, // 201\r\n    StatusCodes.ACCEPTED, // 202\r\n    StatusCodes.NON_AUTHORITATIVE_INFORMATION, // 203\r\n    StatusCodes.NO_CONTENT, // 204\r\n    StatusCodes.RESET_CONTENT, // 205\r\n    StatusCodes.PARTIAL_CONTENT, // 206\r\n    StatusCodes.MULTI_STATUS // 207\r\n  ];\r\n\r\n  config: PoSyncConfig;\r\n  stoppedQueueEventSourcing: boolean = false;\r\n\r\n  private emitter: any;\r\n  private eventSub: Observable<null>;\r\n  private responseSubject = new Subject<PoSyncResponse>();\r\n\r\n  private schemasSyncConfig = {};\r\n\r\n  constructor(\r\n    private poSchemaDefinition: PoSchemaDefinitionService,\r\n    private poSchemaService: PoSchemaService,\r\n    private poStorage: PoStorageService,\r\n    private poHttpClient: PoHttpClientService\r\n  ) {}\r\n\r\n  private static getUrl(eventSourcingItem, schema, requestType): string {\r\n    const schemaUrl = PoSchemaUtil.getUrl(schema, requestType);\r\n    const schemaId = eventSourcingItem.record[schema.idField];\r\n\r\n    if (requestType === PoRequestType.GET) {\r\n      return schemaUrl;\r\n    }\r\n\r\n    if ([PoRequestType.DELETE, PoRequestType.PATCH].includes(requestType)) {\r\n      return schemaUrl ? `${schemaUrl}/${schemaId}` : `${PoSchemaUtil.getUrl(schema, PoRequestType.GET)}/${schemaId}`;\r\n    }\r\n\r\n    if (requestType === PoRequestType.POST) {\r\n      return schemaUrl ? schemaUrl : PoSchemaUtil.getUrl(schema, PoRequestType.GET);\r\n    }\r\n  }\r\n\r\n  create(schemaName: string, newItem: any, customRequestId?: string): Promise<any> {\r\n    const eventSourcingItem = this.createEventSourcingItem(\r\n      PoEventSourcingOperation.Insert,\r\n      newItem,\r\n      schemaName,\r\n      customRequestId\r\n    );\r\n    return this.insertEventSourcingQueue(eventSourcingItem);\r\n  }\r\n\r\n  async createBatchEvents(schemaName: string, eventList: Array<PoEventSourcingSummaryItem>) {\r\n    const eventSourcingList = this.createEventSourcingList(schemaName, eventList);\r\n\r\n    await this.poStorage.appendArrayToArray(PoEventSourcingService.event_sourcing_name, eventSourcingList);\r\n\r\n    this.notifyEventCreation();\r\n  }\r\n\r\n  /**\r\n   * Destrói a chave do *storage* que contém a fila de dados que estão esperando para serem enviados ao\r\n   * servidor *(EventSourcing)*.\r\n   *\r\n   * @returns {Promise<void>} Promessa que é resolvida quando a chave referente a fila de *EventSourcing* for destruída.\r\n   */\r\n  destroyEventSourcingQueue(): Promise<void> {\r\n    return this.poStorage.remove(PoEventSourcingService.event_sourcing_name);\r\n  }\r\n\r\n  async httpCommand(httpOperationData: PoHttpRequestData, customRequestId?: string): Promise<number> {\r\n    httpOperationData = await this.serializeBody(httpOperationData);\r\n\r\n    const eventSourcingItem = this.createEventSourcingItem(\r\n      PoEventSourcingOperation.Http,\r\n      httpOperationData,\r\n      undefined,\r\n      customRequestId\r\n    );\r\n\r\n    await this.insertEventSourcingQueue(eventSourcingItem);\r\n    return eventSourcingItem.id;\r\n  }\r\n\r\n  responsesSubject(): Observable<PoSyncResponse> {\r\n    return this.responseSubject.asObservable();\r\n  }\r\n\r\n  onSaveData(): Observable<null> {\r\n    if (!this.eventSub) {\r\n      this.eventSub = Observable.create(subscriber => (this.emitter = subscriber));\r\n    }\r\n    return this.eventSub;\r\n  }\r\n\r\n  remove(schemaName: string, itemToDelete: any, customRequestId?: string): Promise<any> {\r\n    const eventSourcingItem = this.createEventSourcingItem(\r\n      PoEventSourcingOperation.Delete,\r\n      itemToDelete,\r\n      schemaName,\r\n      customRequestId\r\n    );\r\n    return this.insertEventSourcingQueue(eventSourcingItem);\r\n  }\r\n\r\n  removeEventSourcingItem(idEventSourcingItem) {\r\n    return this.poStorage.removeItemFromArray(PoEventSourcingService.event_sourcing_name, 'id', idEventSourcingItem);\r\n  }\r\n\r\n  syncGet(): Promise<any> {\r\n    const syncGetFunction = async () =>\r\n      this.poSchemaDefinition.getAll().then(schemas => {\r\n        const schemaPromises = this.updateStorageSchemas(schemas);\r\n\r\n        return Promise.all(schemaPromises);\r\n      });\r\n\r\n    return this.poSchemaService.limitedCallWrap(syncGetFunction);\r\n  }\r\n\r\n  async syncSend(): Promise<any> {\r\n    const syncSendFunction = async (): Promise<any> => {\r\n      const itemOfQueue = await this.poStorage.getFirstItem(PoEventSourcingService.event_sourcing_name);\r\n\r\n      if (itemOfQueue) {\r\n        await this.selectOperation(itemOfQueue);\r\n      }\r\n\r\n      if (this.stoppedQueueEventSourcing || !itemOfQueue) {\r\n        this.stoppedQueueEventSourcing = false;\r\n        return Promise.resolve();\r\n      }\r\n\r\n      return syncSendFunction();\r\n    };\r\n\r\n    return this.poSchemaService.limitedCallWrap(syncSendFunction);\r\n  }\r\n\r\n  update(schemaName: string, itemUpdated: any, customRequestId?: string): Promise<any> {\r\n    const eventSourcingItem = this.createEventSourcingItem(\r\n      PoEventSourcingOperation.Update,\r\n      itemUpdated,\r\n      schemaName,\r\n      customRequestId\r\n    );\r\n    return this.insertEventSourcingQueue(eventSourcingItem);\r\n  }\r\n\r\n  /* Avalia se o body é do tipo File e se for converte para base64 */\r\n  private async serializeBody(requestData: PoHttpRequestData): Promise<PoHttpRequestData> {\r\n    let { body, mimeType, bodyType, fileName } = requestData;\r\n\r\n    if (body instanceof File) {\r\n      bodyType = 'File';\r\n      mimeType = body.type;\r\n      fileName = body.name;\r\n      body = await toBase64(body);\r\n    }\r\n\r\n    return { ...requestData, body, mimeType, bodyType, fileName };\r\n  }\r\n\r\n  private buildUrlParams(schema: PoSyncSchema, baseUrl: string, pageNumber: number): string {\r\n    const params = [];\r\n    params.push(`${this.config.dataTransform.getPageSizeParamName()}=${schema.pageSize}`);\r\n    params.push(`${this.config.dataTransform.getPageParamName()}=${pageNumber}`);\r\n    return `${baseUrl}?${params.join('&')}`;\r\n  }\r\n\r\n  private checkRecordIdExists(recordId, operation) {\r\n    if (!recordId) {\r\n      const error = {\r\n        message: 'Identifier not defined',\r\n        operation: operation\r\n      };\r\n\r\n      throw new PoEventSourcingErrorResponse(error);\r\n    }\r\n  }\r\n\r\n  private concatPageItems(pageAcumulator, requestBody): { entity: string; data: Array<any> } {\r\n    if (requestBody[this.config.dataTransform.getItemsFieldName()]) {\r\n      pageAcumulator.data = [...pageAcumulator.data, ...requestBody[this.config.dataTransform.getItemsFieldName()]];\r\n    }\r\n    return pageAcumulator;\r\n  }\r\n\r\n  private createEventSourcingItem(\r\n    operation: PoEventSourcingOperation,\r\n    newItem: any | PoHttpRequestData,\r\n    schemaName?: string,\r\n    customRequestId?: string,\r\n    id?: number\r\n  ): PoEventSourcingItem {\r\n    if (!schemaName && operation !== PoEventSourcingOperation.Http) {\r\n      throw new Error('PoSyncSchema is not defined.');\r\n    }\r\n\r\n    return {\r\n      id: id ? id : new Date().getTime(),\r\n      dateTime: new Date().getTime(),\r\n      schema: schemaName,\r\n      operation: operation,\r\n      record: newItem,\r\n      customRequestId: customRequestId\r\n    };\r\n  }\r\n\r\n  private createEventSourcingList(\r\n    schemaName: string,\r\n    eventList: Array<PoEventSourcingSummaryItem>\r\n  ): Array<PoEventSourcingItem> {\r\n    return eventList.map((eventItem, index) => {\r\n      const id = new Date().getTime() + index;\r\n\r\n      return this.createEventSourcingItem(\r\n        eventItem.operation,\r\n        eventItem.record,\r\n        schemaName,\r\n        eventItem.customRequestId,\r\n        id\r\n      );\r\n    });\r\n  }\r\n\r\n  private createSchemaSyncConfig(schemaName) {\r\n    this.schemasSyncConfig[schemaName] = {\r\n      page: undefined,\r\n      currentUrlDiff: undefined,\r\n      responseDate: undefined\r\n    };\r\n  }\r\n\r\n  private async deleteOperation(eventSourcingItem: PoEventSourcingItem): Promise<any> {\r\n    try {\r\n      const schema = await this.poSchemaDefinition.get(eventSourcingItem.schema);\r\n\r\n      const recordId = eventSourcingItem.record[schema.idField];\r\n      this.checkRecordIdExists(recordId, PoEventSourcingOperation.Delete);\r\n\r\n      const url = PoEventSourcingService.getUrl(eventSourcingItem, schema, PoRequestType.DELETE);\r\n      const response = await this.sendServerItem(url, PoHttpRequestType.DELETE);\r\n\r\n      await this.removeEventSourcingValidItem(response.status, eventSourcingItem);\r\n\r\n      return await this.sendResponseSubject(eventSourcingItem, response);\r\n    } catch (errorResponse) {\r\n      return this.sendResponseSubject(eventSourcingItem, errorResponse, true);\r\n    }\r\n  }\r\n\r\n  private diffServerItems(currentUrlDiff): Observable<HttpResponse<Object>> {\r\n    return this.poHttpClient.get(currentUrlDiff);\r\n  }\r\n\r\n  private getBodyAndDate(schemaName, response): any {\r\n    const getDateFieldName = this.config.dataTransform.getDateFieldName();\r\n\r\n    const responseSyncDate = response.body[getDateFieldName];\r\n\r\n    this.schemasSyncConfig[schemaName]['responseDate'] = responseSyncDate;\r\n    return response.body;\r\n  }\r\n\r\n  private async getServerDiffRecords(schema: PoSyncSchema, baseUrl: string): Promise<any> {\r\n    const initialAcumulatorPage = { entity: schema.name, data: [] };\r\n    const diffUrl = this.schemasSyncConfig[schema.name]['currentUrlDiff'];\r\n\r\n    const serverResponse = await this.diffServerItems(diffUrl)\r\n      .pipe(\r\n        map(response => this.getBodyAndDate(schema.name, response)),\r\n        expand(data => this.paginateSchemaData(data, schema, baseUrl)),\r\n        reduce(\r\n          (pageAcumulator, requestBody) => this.concatPageItems(pageAcumulator, requestBody),\r\n          initialAcumulatorPage\r\n        )\r\n      )\r\n      .toPromise();\r\n\r\n    return serverResponse.data;\r\n  }\r\n\r\n  private async httpOperation(eventSourcingItem: PoEventSourcingItem): Promise<Array<PoEventSourcingItem> | number> {\r\n    try {\r\n      const requestData: PoHttpRequestData = await this.createPoHttpRequestData(\r\n        eventSourcingItem.record.url,\r\n        eventSourcingItem.record.method,\r\n        eventSourcingItem.record,\r\n        eventSourcingItem.record.headers\r\n      );\r\n      const response = await this.poHttpClient.createRequest(requestData).toPromise();\r\n      const poHttpCommandResponse: PoSyncResponse = {\r\n        id: eventSourcingItem.id,\r\n        customRequestId: eventSourcingItem.customRequestId,\r\n        request: eventSourcingItem.record,\r\n        response: response\r\n      };\r\n\r\n      this.responseSubject.next(poHttpCommandResponse);\r\n\r\n      return this.removeEventSourcingValidItem(response.status, eventSourcingItem);\r\n    } catch (errorHttpClient) {\r\n      return this.sendResponseSubject(eventSourcingItem, errorHttpClient, true);\r\n    }\r\n  }\r\n\r\n  private async insertEventSourcingQueue(eventSourcingItem): Promise<Array<PoEventSourcingItem>> {\r\n    const eventSourcingUpdatedQueue = await this.poStorage.appendItemToArray(\r\n      PoEventSourcingService.event_sourcing_name,\r\n      eventSourcingItem\r\n    );\r\n\r\n    this.notifyEventCreation();\r\n\r\n    return Promise.resolve(eventSourcingUpdatedQueue);\r\n  }\r\n\r\n  private async insertOperation(currentEventSourcingItem: PoEventSourcingItem): Promise<any> {\r\n    const schema = await this.poSchemaDefinition.get(currentEventSourcingItem.schema);\r\n    const url = PoEventSourcingService.getUrl(currentEventSourcingItem, schema, PoRequestType.POST);\r\n\r\n    try {\r\n      const response = await this.sendServerItem(url, PoHttpRequestType.POST, currentEventSourcingItem.record);\r\n      const recordUpdatedByServer = response.body;\r\n\r\n      await this.removeEventSourcingValidItem(response.status, currentEventSourcingItem);\r\n\r\n      const id = currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName];\r\n      await this.poSchemaService.update(schema, recordUpdatedByServer, id);\r\n\r\n      const eventSourcingItems: Array<PoEventSourcingItem> = await this.poStorage.get(\r\n        PoEventSourcingService.event_sourcing_name\r\n      );\r\n      await this.updatePendingEventSourcing(\r\n        currentEventSourcingItem,\r\n        schema.idField,\r\n        recordUpdatedByServer,\r\n        eventSourcingItems\r\n      );\r\n\r\n      return this.sendResponseSubject(currentEventSourcingItem, response);\r\n    } catch (errorHttpClient) {\r\n      return this.sendResponseSubject(currentEventSourcingItem, errorHttpClient, true);\r\n    }\r\n  }\r\n\r\n  private isValidStatus(status: number): boolean {\r\n    return PoEventSourcingService.VALID_HTTP_STATUS_CODES.includes(status);\r\n  }\r\n\r\n  private notifyEventCreation(): void {\r\n    if (this.emitter) {\r\n      this.emitter.next();\r\n    }\r\n  }\r\n\r\n  private paginateSchemaData(data, schema, baseUrl): Observable<null> {\r\n    this.config.dataTransform.transform(data);\r\n\r\n    if (this.config.dataTransform.hasNext()) {\r\n      this.schemasSyncConfig[schema.name]['currentUrlDiff'] = this.buildUrlParams(\r\n        schema,\r\n        baseUrl,\r\n        ++this.schemasSyncConfig[schema.name]['page']\r\n      );\r\n\r\n      return this.diffServerItems(this.schemasSyncConfig[schema.name]['currentUrlDiff']).pipe(\r\n        map(response => this.getBodyAndDate(schema.name, response))\r\n      );\r\n    }\r\n\r\n    return of();\r\n  }\r\n\r\n  private removeEventSourcingValidItem(\r\n    status,\r\n    eventSourcingItem: PoEventSourcingItem\r\n  ): Promise<Array<PoEventSourcingItem>> {\r\n    if (this.isValidStatus(status) || eventSourcingItem.operation === PoEventSourcingOperation.Http) {\r\n      return this.removeEventSourcingItem(eventSourcingItem.id);\r\n    }\r\n  }\r\n\r\n  private selectOperation(eventSourcingItem: PoEventSourcingItem): Promise<any> {\r\n    switch (eventSourcingItem.operation) {\r\n      case PoEventSourcingOperation.Insert:\r\n        return this.insertOperation(eventSourcingItem);\r\n\r\n      case PoEventSourcingOperation.Update:\r\n        return this.updateOperation(eventSourcingItem);\r\n\r\n      case PoEventSourcingOperation.Delete:\r\n        return this.deleteOperation(eventSourcingItem);\r\n\r\n      case PoEventSourcingOperation.Http:\r\n        return this.httpOperation(eventSourcingItem);\r\n    }\r\n  }\r\n\r\n  private sendResponseSubject(\r\n    eventSourcingItem: PoEventSourcingItem,\r\n    response: HttpResponse<Object> | HttpErrorResponse | PoEventSourcingErrorResponse,\r\n    isSubjectError: boolean = false\r\n  ): Promise<any> {\r\n    const poSyncResponse: PoSyncResponse = {\r\n      id: eventSourcingItem.id,\r\n      customRequestId: eventSourcingItem.customRequestId,\r\n      request: eventSourcingItem.record,\r\n      response: response\r\n    };\r\n\r\n    this.stoppedQueueEventSourcing = isSubjectError;\r\n    this.responseSubject.next(poSyncResponse);\r\n\r\n    return Promise.resolve();\r\n  }\r\n\r\n  private async sendServerItem(url: string, method: PoHttpRequestType, body?: PoEventSourcingItem['record']) {\r\n    const requestData: PoHttpRequestData = await this.createPoHttpRequestData(url, method, body);\r\n\r\n    return this.poHttpClient.createRequest(requestData).toPromise();\r\n  }\r\n\r\n  private async createPoHttpRequestData(\r\n    url: string,\r\n    method: PoHttpRequestType,\r\n    record?: PoEventSourcingItem['record'],\r\n    headers?: Array<PoHttpHeaderOption>\r\n  ): Promise<PoHttpRequestData> {\r\n    let body = record.body ?? record;\r\n\r\n    if (record.bodyType === 'File') {\r\n      body = await this.createFormData(body, record.fileName, record.mimeType, record.formField);\r\n    }\r\n\r\n    return { url, method, body, headers };\r\n  }\r\n\r\n  private async createFormData(\r\n    body: string,\r\n    fileName: string,\r\n    mimeType: string,\r\n    formField: string = 'file'\r\n  ): Promise<FormData> {\r\n    const file = await toFile(body, fileName, mimeType);\r\n    const formData: FormData = new FormData();\r\n\r\n    formData.append(formField, file, fileName);\r\n    return formData;\r\n  }\r\n\r\n  private async updateOperation(eventSourcingItem: PoEventSourcingItem): Promise<Array<any> | number> {\r\n    const schema = await this.poSchemaDefinition.get(eventSourcingItem.schema);\r\n    const url = PoEventSourcingService.getUrl(eventSourcingItem, schema, PoRequestType.PATCH);\r\n\r\n    try {\r\n      const recordId = eventSourcingItem.record[schema.idField];\r\n      this.checkRecordIdExists(recordId, PoEventSourcingOperation.Update);\r\n\r\n      const response = await this.sendServerItem(url, PoHttpRequestType.PUT, eventSourcingItem.record);\r\n      await this.removeEventSourcingValidItem(response.status, eventSourcingItem);\r\n\r\n      return await this.sendResponseSubject(eventSourcingItem, response);\r\n    } catch (errorHttpClient) {\r\n      return this.sendResponseSubject(eventSourcingItem, errorHttpClient, true);\r\n    }\r\n  }\r\n\r\n  private updatePendingEventSourcing(\r\n    currentEventSourcingItem: PoEventSourcingItem,\r\n    idFieldSchema: string,\r\n    inserted: object,\r\n    eventSourcingItems: Array<PoEventSourcingItem>\r\n  ) {\r\n    if (currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName]) {\r\n      eventSourcingItems.forEach((eventSourcingItem, position) => {\r\n        const isCurrentEventSourcingItem =\r\n          !eventSourcingItem.record[idFieldSchema] &&\r\n          eventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName] ===\r\n            currentEventSourcingItem.record[PoSchemaUtil.syncInternalIdFieldName];\r\n\r\n        if (isCurrentEventSourcingItem) {\r\n          eventSourcingItems[position].record[idFieldSchema] = inserted[idFieldSchema];\r\n        }\r\n      });\r\n\r\n      return this.poStorage.set(PoEventSourcingService.event_sourcing_name, eventSourcingItems);\r\n    } else {\r\n      return Promise.resolve();\r\n    }\r\n  }\r\n\r\n  private async updateRecords(serverRecords: Array<any>, schema: PoSyncSchema) {\r\n    for (const serverRecord of serverRecords) {\r\n      await this.updateRecordByServerRecord(serverRecord, schema);\r\n    }\r\n  }\r\n\r\n  private async updateRecordByServerRecord(serverRecord, schema) {\r\n    const recordId = serverRecord[schema.idField];\r\n    const storageRecord = await this.poSchemaService.get(schema.name, recordId);\r\n    const existsStorageRecord = !!Object.keys(storageRecord).length;\r\n\r\n    if (existsStorageRecord && serverRecord[schema.deletedField]) {\r\n      return await this.poSchemaService.remove(schema.name, serverRecord[schema.idField]);\r\n    }\r\n\r\n    if (existsStorageRecord && !serverRecord[schema.deletedField]) {\r\n      return await this.poSchemaService.update(schema, serverRecord);\r\n    }\r\n\r\n    if (!existsStorageRecord && !serverRecord[schema.deletedField]) {\r\n      return await this.poSchemaService.create(schema, serverRecord);\r\n    }\r\n  }\r\n\r\n  private async updateStorageBySchema(schema: PoSyncSchema): Promise<any> {\r\n    this.createSchemaSyncConfig(schema.name);\r\n\r\n    this.schemasSyncConfig[schema.name]['page'] = 1;\r\n    const baseUrl = `${PoSchemaUtil.getUrl(schema, PoRequestType.DIFF)}/${schema.lastSync}`;\r\n    this.schemasSyncConfig[schema.name]['currentUrlDiff'] = this.buildUrlParams(\r\n      schema,\r\n      baseUrl,\r\n      this.schemasSyncConfig[schema.name]['page']\r\n    );\r\n\r\n    const serverRecords = await this.getServerDiffRecords(schema, baseUrl);\r\n\r\n    await this.updateRecords(serverRecords, schema);\r\n\r\n    schema.lastSync = this.schemasSyncConfig[schema.name]['responseDate'];\r\n    await this.poSchemaDefinition.update(schema);\r\n  }\r\n\r\n  private updateStorageSchemas(schemas): Array<Promise<Array<any>>> {\r\n    return schemas.map((schema: PoSyncSchema) => this.updateStorageBySchema(schema));\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/services/po-http-client/interfaces/po-http-header-option.interface.mjs

@@ -1,11 +1,11 @@
-/**
- * @docsPrivate
- *
- * @usedBy PoHttpClientService
- *
- * @description
- *
- * Define o cabeçalho da requisição HTTP.
- */
-export {};
+/**
+ * @docsPrivate
+ *
+ * @usedBy PoHttpClientService
+ *
+ * @description
+ *
+ * Define o cabeçalho da requisição HTTP.
+ */
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8taHR0cC1oZWFkZXItb3B0aW9uLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL2xpYi9zZXJ2aWNlcy9wby1odHRwLWNsaWVudC9pbnRlcmZhY2VzL3BvLWh0dHAtaGVhZGVyLW9wdGlvbi5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGRvY3NQcml2YXRlXHJcbiAqXHJcbiAqIEB1c2VkQnkgUG9IdHRwQ2xpZW50U2VydmljZVxyXG4gKlxyXG4gKiBAZGVzY3JpcHRpb25cclxuICpcclxuICogRGVmaW5lIG8gY2FiZcOnYWxobyBkYSByZXF1aXNpw6fDo28gSFRUUC5cclxuICovXHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFBvSHR0cEhlYWRlck9wdGlvbiB7XHJcbiAgLyoqIE5vbWUgZG8gY2FiZcOnYWxoby4gKi9cclxuICBuYW1lOiBzdHJpbmc7XHJcblxyXG4gIC8qKiBWYWxvciBkbyBjYWJlw6dhbGhvLiAqL1xyXG4gIHZhbHVlOiBzdHJpbmc7XHJcbn1cclxuIl19

package/{esm2020 → esm2022}/lib/services/po-http-client/interfaces/po-http-request-data.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8taHR0cC1yZXF1ZXN0LWRhdGEuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc3luYy9zcmMvbGliL3NlcnZpY2VzL3BvLWh0dHAtY2xpZW50L2ludGVyZmFjZXMvcG8taHR0cC1yZXF1ZXN0LWRhdGEuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb0h0dHBIZWFkZXJPcHRpb24gfSBmcm9tICcuL3BvLWh0dHAtaGVhZGVyLW9wdGlvbi5pbnRlcmZhY2UnO1xyXG5pbXBvcnQgeyBQb0h0dHBSZXF1ZXN0VHlwZSB9IGZyb20gJy4vLi4vcG8taHR0cC1yZXF1ZXN0LXR5cGUuZW51bSc7XHJcblxyXG4vKipcclxuICogQHVzZWRCeSBQb1N5bmNTZXJ2aWNlXHJcbiAqXHJcbiAqIEBkZXNjcmlwdGlvblxyXG4gKlxyXG4gKiBJbnRlcmZhY2UgcGFyYSBkZWZpbmnDp8OjbyBkZSB1bWEgcmVxdWlzacOnw6NvIEhUVFAuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFBvSHR0cFJlcXVlc3REYXRhIHtcclxuICAvKiogVVJMIHF1ZSBzZXLDoSB1dGlsaXphZGEgbmEgcmVxdWlzacOnw6NvLiAqL1xyXG4gIHVybDogc3RyaW5nO1xyXG5cclxuICAvKiogQ2FiZcOnYWxobyBkYSByZXF1aXNpw6fDo28uICovXHJcbiAgaGVhZGVycz86IEFycmF5PFBvSHR0cEhlYWRlck9wdGlvbj47XHJcblxyXG4gIC8qKiBNw6l0b2RvIEhUVFAgcXVlIHNlcsOhIHV0aWxpemFkby4gKi9cclxuICBtZXRob2Q6IFBvSHR0cFJlcXVlc3RUeXBlO1xyXG5cclxuICAvKiogQ29ycG8gZGEgcmVxdWlzacOnw6NvLiAqL1xyXG4gIGJvZHk/OiBhbnk7XHJcblxyXG4gIC8qKiBOb21lIGRhIHByb3ByaWVkYWRlIHF1ZSBjb250ZXLDoSBvIGFycXVpdm8gZW52aWFkbyBwYXJhIG8gc2Vydmlkb3IgKi9cclxuICBmb3JtRmllbGQ/OiBzdHJpbmc7XHJcblxyXG4gIC8vIFRpcG8gZG8gYm9keVxyXG4gIGJvZHlUeXBlPzogc3RyaW5nO1xyXG5cclxuICAvLyBNaW1lVHlwZSBkYSByZXF1aXNpw6fDo28gY2FzbyBzZWphIHVtIGFycXVpdm9cclxuICBtaW1lVHlwZT86IHN0cmluZztcclxuXHJcbiAgLy8gTm9tZSBkbyBhcnF1aXZvXHJcbiAgZmlsZU5hbWU/OiBzdHJpbmc7XHJcbn1cclxuIl19

package/{esm2020 → esm2022}/lib/services/po-http-client/interfaces/po-response-api.interface.mjs

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