@sincpro/mobile 0.4.4 → 1.0.0

package/dist/infrastructure/workers/EventBus.js

@@ -1,8 +1,10 @@
 import { DomainEventRepository } from "../../adapters/repositories/domain_event.repository";
 import { DomainEventDeadLetterRepository } from "../../adapters/repositories/domain_event_dead_letter.repository";
-import { InternetIsDownEvent, InternetIsUpEvent, QueueEndEvent, QueueStartEvent, } from "../../domain/events";
-import { DomainNetworkError } from "../../exceptions";
+import { InternetIsDownEvent, InternetIsUpEvent } from "../../domain/events";
+import { DomainNetworkError, RepeatableFailure } from "../../exceptions";
+import { runWithChain } from "../../infrastructure/event_chain";
 import { loggerQueueProcessor } from "../../infrastructure/logger";
+import { declaresUi, publishActivity } from "../../infrastructure/ui/activity";
 import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
 export const PROCESS_WORKER_MAX_ATTEMPTS = 1;
 export class EventBus {
@@ -12,11 +14,15 @@ export class EventBus {
     static BACKOFF_MULTIPLIER = 1.5;
     static subscribers = new Map();
     static isDraining = false;
+    static connectivityReady = false;
     static intervalId = null;
     static internetConnected = true;
     static consecutiveFailures = 0;
     static currentInterval = EventBus.INTERVAL_MS;
     static initConnectivityListeners() {
+        if (this.connectivityReady)
+            return;
+        this.connectivityReady = true;
         UIEventBus.on(InternetIsDownEvent.name, () => {
             this.internetConnected = false;
             this.consecutiveFailures++;
@@ -102,27 +108,22 @@ export class EventBus {
         }
     }
     /**
-     * Validates event, logs start, emits START.
+     * Logs the start and publishes a running activity when a subscriber exists.
      * Returns false if no subscribers (caller should return early).
      */
     static preProcess(event) {
         const hasSubscribers = this.subscribers.has(event.name);
         loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] (attempt ${event.attempts}/${EventBus.MAX_ATTEMPTS}) - STARTED`);
         loggerQueueProcessor.debug(`EVENT=${event.name} uuid=${event.uuid} payload=${event.asJSON()}`);
-        const queueStartEvent = QueueStartEvent.create();
-        UIEventBus.emit(queueStartEvent.name, {
-            event: event.name,
-            label: event.label,
-            attempts: event.attempts,
-            attemptLimit: EventBus.MAX_ATTEMPTS,
-        });
+        if (hasSubscribers)
+            this.publishQueue(event, "running");
         if (!hasSubscribers) {
             loggerQueueProcessor.warn(`EVENT=${event.name} [${event.label}] - No subscribers registered`);
         }
         return hasSubscribers;
     }
     /**
-     * Handles persistence, emits event and END, logs result.
+     * Handles persistence, emits the event for screens, publishes the activity, logs result.
      * If errors is empty -> success, otherwise -> failure + dead letter + throws.
      * @throws Error if there are any errors
      */
@@ -141,14 +142,7 @@ export class EventBus {
             loggerQueueProcessor.warn(`EVENT=${event.name} [${event.label}] (attempt ${event.attempts}/${EventBus.MAX_ATTEMPTS}) - FAILED: ${errorMessage}`);
         }
         UIEventBus.emit(event.name, event);
-        UIEventBus.emit(QueueEndEvent.name, {
-            event: event.name,
-            label: event.label,
-            success,
-            attempts: event.attempts,
-            attemptLimit: EventBus.MAX_ATTEMPTS,
-            error: errorMessage,
-        });
+        this.publishQueue(event, success ? "succeeded" : "failed", errorMessage);
         if (!success) {
             throw new Error(errorMessage);
         }
@@ -162,12 +156,15 @@ export class EventBus {
             }
             catch (err) {
                 const errorMessage = err instanceof Error ? err.message : String(err);
-                errors.push(errorMessage);
                 loggerQueueProcessor.warn(`EVENT=${event.name} - Subscriber failed: ${errorMessage}`);
-                if (err instanceof DomainNetworkError) {
-                    this.internetConnected = false;
-                    UIEventBus.emit(InternetIsDownEvent.name);
+                if (err instanceof DomainNetworkError || err instanceof RepeatableFailure) {
+                    if (err instanceof DomainNetworkError) {
+                        this.internetConnected = false;
+                        UIEventBus.emit(InternetIsDownEvent.name);
+                    }
+                    throw new RepeatableFailure(errorMessage);
                 }
+                errors.push(errorMessage);
             }
         }
         return errors;
@@ -220,7 +217,12 @@ export class EventBus {
     /**
      * Publishes a DomainEvent asynchronously - enqueues for later processing.
      */
+    static schedule() {
+        this.triggerProcessing();
+    }
     static async publish(event) {
+        if (!event.correlationId)
+            event.applyChain(event.uuid);
         loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] - Published ASYNC`);
         await DomainEventRepository.save(event);
         this.triggerProcessing();
@@ -231,6 +233,8 @@ export class EventBus {
      * @throws Error if any subscriber fails or no subscribers registered
      */
     static async publishSync(event) {
+        if (!event.correlationId)
+            event.applyChain(event.uuid);
         loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] - Published SYNC`);
         event.markAsProcessing();
         await DomainEventRepository.save(event);
@@ -239,8 +243,18 @@ export class EventBus {
             return;
         }
         const subscriberList = this.subscribers.get(event.name);
-        const errors = await this.executeSubscribers(event, subscriberList);
-        await this.postProcess(event, errors);
+        try {
+            const errors = await this.executeSubscribers(event, subscriberList);
+            await this.postProcess(event, errors);
+        }
+        catch (err) {
+            if (err instanceof RepeatableFailure) {
+                event.retry();
+                await DomainEventRepository.save(event);
+                this.publishQueue(event, "idle");
+            }
+            throw err;
+        }
     }
     /**
      * Processes all pending DomainEvents from the domain_events table.
@@ -250,18 +264,29 @@ export class EventBus {
     static async drainAll() {
         let event;
         while ((event = await DomainEventRepository.findNextPending(this.internetConnected))) {
+            const current = event;
             try {
-                event.markAsProcessing();
-                await DomainEventRepository.save(event);
-                if (!this.preProcess(event)) {
-                    await this.postProcess(event, ["No subscribers registered"]);
+                current.markAsProcessing();
+                await DomainEventRepository.save(current);
+                if (!this.preProcess(current)) {
+                    await this.postProcess(current, ["No subscribers registered"]);
                     continue;
                 }
-                const subscriberList = this.subscribers.get(event.name);
-                const errors = await this.executeSubscribers(event, subscriberList);
-                await this.postProcess(event, errors);
+                const subscriberList = this.subscribers.get(current.name);
+                const errors = await runWithChain({
+                    causationId: current.uuid,
+                    correlationId: current.correlationId ?? current.uuid,
+                }, () => this.executeSubscribers(current, subscriberList));
+                await this.postProcess(current, errors);
+            }
+            catch (err) {
+                if (err instanceof RepeatableFailure) {
+                    current.retry();
+                    await DomainEventRepository.save(current);
+                    this.publishQueue(current, "idle");
+                    break;
+                }
             }
-            catch { }
         }
     }
     /**
@@ -276,4 +301,14 @@ export class EventBus {
             loggerQueueProcessor.warn("Failed to clear ProcessWorker queue:", error);
         }
     }
+    static publishQueue(event, status, detail) {
+        publishActivity({
+            channel: "queue",
+            name: event.name,
+            label: event.labelText(),
+            detail,
+            status,
+            ui: declaresUi(event),
+        });
+    }
 }

package/dist/services/bluetooth.service.js

@@ -1,7 +1,6 @@
 import { BluetoothAdapter } from "../adapters/Bluetooth.adapter";
 import { loggerUseCases } from "../infrastructure/logger";
-import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
-import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+import { notifyDevice } from "../infrastructure/ui/activity";
 class BluetoothService {
     permissionStatus = null;
     async requestPermissions() {
@@ -36,10 +35,11 @@ class BluetoothService {
         loggerUseCases.info("Ensuring Bluetooth permissions for printer connection");
         const permissions = await this.ensurePermissions();
         if (!permissions) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Permisos de Bluetooth requeridos",
-                text2: "Habilita los permisos de Bluetooth en configuración",
+            notifyDevice({
+                name: "bluetooth.required",
+                title: "Permisos de Bluetooth requeridos",
+                message: "Habilita los permisos de Bluetooth en configuración",
+                variant: "danger",
             });
         }
         return permissions;
@@ -52,18 +52,20 @@ class BluetoothService {
     }
     showPermissionToast(permissions) {
         if (permissions.isGranted) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Bluetooth habilitado",
-                text2: "Permisos de Bluetooth concedidos",
+            notifyDevice({
+                name: "bluetooth.enabled",
+                title: "Bluetooth habilitado",
+                message: "Permisos de Bluetooth concedidos",
+                variant: "success",
             });
             loggerUseCases.info("Bluetooth permissions granted");
         }
         else {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Bluetooth no disponible",
-                text2: "Los permisos de Bluetooth fueron denegados",
+            notifyDevice({
+                name: "bluetooth.denied",
+                title: "Bluetooth no disponible",
+                message: "Los permisos de Bluetooth fueron denegados",
+                variant: "danger",
             });
             loggerUseCases.warn("Bluetooth permissions denied", { permissions });
         }

package/dist/services/dead_letter_queue.service.d.ts

@@ -1,23 +1,23 @@
-import { DomainEvent } from "../domain/event_sourcing";
+import { IntegrationEvent } from "../domain/events";
 declare class DeadLetterQueueUseCases {
     private get repository();
     /**
      * Retrieves all failed events from the dead letter queue.
      */
-    getFailedEvents(): Promise<DomainEvent[]>;
+    getFailedEvents(): Promise<IntegrationEvent[]>;
     /**
      * Retrieves a specific failed event by uuid.
      */
-    getFailedEventById(uuid: string): Promise<DomainEvent | null>;
+    getFailedEventById(uuid: string): Promise<IntegrationEvent | null>;
     /**
      * Manually retries a failed event by re-queuing it for processing.
      * This removes the event from the dead letter queue and adds it back to the processing queue.
      */
-    retryFailedEvent(event: DomainEvent): Promise<void>;
+    retryFailedEvent(event: IntegrationEvent): Promise<void>;
     /**
      * Retries multiple failed events in batch.
      */
-    retryMultipleFailedEvents(events: DomainEvent[]): Promise<{
+    retryMultipleFailedEvents(events: IntegrationEvent[]): Promise<{
         success: number;
         failed: number;
     }>;
@@ -25,11 +25,11 @@ declare class DeadLetterQueueUseCases {
      * Permanently deletes a failed event from the dead letter queue.
      * Use with caution as this action cannot be undone.
      */
-    deleteFailedEvent(event: DomainEvent): Promise<void>;
+    deleteFailedEvent(event: IntegrationEvent): Promise<void>;
     /**
      * Deletes multiple failed events in batch.
      */
-    deleteMultipleFailedEvents(events: DomainEvent[]): Promise<{
+    deleteMultipleFailedEvents(events: IntegrationEvent[]): Promise<{
         success: number;
         failed: number;
     }>;

package/dist/services/dead_letter_queue.service.js

@@ -27,9 +27,7 @@ class DeadLetterQueueUseCases {
     async retryFailedEvent(event) {
         loggerUseCases.info(`Manually retrying failed event: ${event.name} (uuid: ${event.uuid})`);
         try {
-            // Reset the event for retry
             event.retry();
-            // Re-queue the event using V2 API
             await EventBus.publish(event);
             // Remove from dead letter queue only after successful re-queuing
             await this.repository.remove(event.uuid);

package/dist/services/event.service.d.ts

@@ -1,7 +1,7 @@
-import { DomainEvent } from "../domain/event_sourcing";
+import { type IntegrationEvent } from "../domain/events";
 declare class EventService {
-    listAllEvents(): Promise<DomainEvent[]>;
-    republishSync(event: DomainEvent): Promise<void>;
+    listAllEvents(): Promise<IntegrationEvent[]>;
+    republishSync(event: IntegrationEvent): Promise<void>;
 }
 export declare const eventService: EventService;
 export {};

package/dist/services/event.service.js

@@ -1,5 +1,5 @@
 import { DomainEventRepository } from "../adapters/repositories/domain_event.repository";
-import { EEventStatus } from "../domain/event_sourcing";
+import { EEventStatus } from "../domain/events";
 import { loggerUseCases } from "../infrastructure/logger";
 import { EventBus } from "../infrastructure/workers/EventBus";
 class EventService {

package/dist/services/network.service.d.ts

@@ -2,6 +2,6 @@ import { NetworkStatus } from "../domain/connectivity";
 export declare class NetworkUseCases {
     private networkStatus;
     getNetworkStatus(): Promise<NetworkStatus>;
-    showToastNotification(networkStatus: NetworkStatus): Promise<void>;
+    private notifyOnChange;
 }
 export declare const networkUseCases: NetworkUseCases;

package/dist/services/network.service.js

@@ -1,7 +1,7 @@
 import { NetworkAdapter } from "../adapters/Network.adapter";
 import { InternetIsDownEvent, InternetIsUpEvent } from "../domain/events";
 import { loggerUseCases } from "../infrastructure/logger";
-import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
+import { notifyDevice } from "../infrastructure/ui/activity";
 import { UIEventBus } from "../infrastructure/ui/UIEventBus";
 export class NetworkUseCases {
     networkStatus = null;
@@ -13,29 +13,31 @@ export class NetworkUseCases {
         else {
             UIEventBus.emit(InternetIsDownEvent.name, false);
         }
-        this.showToastNotification(networkStatus);
+        this.notifyOnChange(networkStatus);
         this.networkStatus = networkStatus;
         return this.networkStatus;
     }
-    async showToastNotification(networkStatus) {
-        const showToast = networkStatus.isConnected !== this.networkStatus?.isConnected;
-        if (!showToast) {
+    notifyOnChange(networkStatus) {
+        const changed = networkStatus.isConnected !== this.networkStatus?.isConnected;
+        if (!changed) {
             return;
         }
         if (!networkStatus.isConnected) {
-            loggerUseCases.info(`Network is up: ${networkStatus.type}`);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Estas desconectado",
-                text2: "Sin conexión a internet",
+            loggerUseCases.warn(`Network is down: ${networkStatus.type}`);
+            notifyDevice({
+                name: "network.offline",
+                title: "Estas desconectado",
+                message: "Sin conexión a internet",
+                variant: "danger",
             });
         }
         else {
-            loggerUseCases.warn(`Network is down: ${networkStatus.type}`);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Conectado",
-                text2: `Conexión a través de ${networkStatus.type}`,
+            loggerUseCases.info(`Network is up: ${networkStatus.type}`);
+            notifyDevice({
+                name: "network.online",
+                title: "Conectado",
+                message: `Conexión a través de ${networkStatus.type}`,
+                variant: "success",
             });
         }
     }

package/dist/services/printer.service.d.ts

@@ -9,7 +9,7 @@ declare class PrinterService {
     getPairedDevices(): BluetoothDevice[];
     getPairedPrinters(): PairedPrinter[];
     isConnected(): boolean;
-    connect(address: string, name: string): Promise<boolean>;
+    connect(address: string, name: string, notify?: boolean): Promise<boolean>;
     disconnect(): Promise<void>;
     getSelectedPrinter(): Promise<ISelectedPrinter | null>;
     saveSelectedPrinter(printer: ISelectedPrinter): Promise<void>;

package/dist/services/printer.service.js

@@ -3,8 +3,7 @@ import { SettingsRepository } from "../adapters/repositories/setting.repository"
 import { getPrinterDriver, hasPrinterDriver, setPrinterDriver, } from "../domain/print";
 import { ECommonSetting } from "../domain/settings";
 import { loggerUseCases } from "../infrastructure/logger";
-import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
-import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+import { notifyDevice } from "../infrastructure/ui/activity";
 import { File } from "expo-file-system";
 import * as Print from "expo-print";
 import { bluetoothService } from "./bluetooth.service";
@@ -26,7 +25,7 @@ class PrinterService {
     isConnected() {
         return getPrinterDriver().isConnected();
     }
-    async connect(address, name) {
+    async connect(address, name, notify = true) {
         const hasPermissions = await this.bluetooth.ensurePermissionsForPrinter();
         if (!hasPermissions) {
             return false;
@@ -39,30 +38,37 @@ class PrinterService {
                 selectedAt: new Date().toISOString(),
             };
             await this.saveSelectedPrinter(printer);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresora conectada",
-                text2: `Conectado a ${name}`,
-            });
+            if (notify) {
+                notifyDevice({
+                    name: "printer.connected",
+                    title: "Impresora conectada",
+                    message: `Conectado a ${name}`,
+                    variant: "success",
+                });
+            }
             return true;
         }
         catch (error) {
             loggerUseCases.error(`Failed to connect to printer: ${name}`, error);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Error de conexión",
-                text2: `No se pudo conectar a ${name}`,
-            });
+            if (notify) {
+                notifyDevice({
+                    name: "printer.connect_failed",
+                    title: "Error de conexión",
+                    message: `No se pudo conectar a ${name}`,
+                    variant: "danger",
+                });
+            }
             return false;
         }
     }
     async disconnect() {
         try {
             await getPrinterDriver().disconnect();
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "info",
-                text1: "Desconectado",
-                text2: "Impresora desconectada",
+            notifyDevice({
+                name: "printer.disconnected",
+                title: "Desconectado",
+                message: "Impresora desconectada",
+                variant: "info",
             });
         }
         catch (error) {
@@ -87,10 +93,11 @@ class PrinterService {
     }
     async printTestPage() {
         if (!this.isConnected()) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Sin conexión",
-                text2: "Conecta una impresora primero",
+            notifyDevice({
+                name: "printer.not_connected",
+                title: "Sin conexión",
+                message: "Conecta una impresora primero",
+                variant: "danger",
             });
             return false;
         }
@@ -108,19 +115,21 @@ class PrinterService {
                 alignment: "center",
                 fontSize: "small",
             });
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresión exitosa",
-                text2: "Página de prueba impresa",
+            notifyDevice({
+                name: "printer.test_ok",
+                title: "Impresión exitosa",
+                message: "Página de prueba impresa",
+                variant: "success",
             });
             return true;
         }
         catch (error) {
             loggerUseCases.error("Error printing test page", error);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Error de impresión",
-                text2: "No se pudo imprimir la página de prueba",
+            notifyDevice({
+                name: "printer.test_failed",
+                title: "Error de impresión",
+                message: "No se pudo imprimir la página de prueba",
+                variant: "danger",
             });
             return false;
         }
@@ -137,18 +146,13 @@ class PrinterService {
             loggerUseCases.warn("Print failed — attempting grace reconnect", firstError);
             const reconnected = await this.forceReconnect();
             if (!reconnected)
-                return false; // connect() ya notificó al usuario
+                return false;
             try {
                 await getPrinterDriver().printImageBase64(base64Data);
                 return true;
             }
             catch (retryError) {
                 loggerUseCases.error("Print retry after reconnect also failed", retryError);
-                UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                    type: "error",
-                    text1: "Error de impresión",
-                    text2: "No se pudo imprimir incluso tras reconectar la impresora",
-                });
                 return false;
             }
         }
@@ -164,10 +168,11 @@ class PrinterService {
                 return false;
             }
             await getPrinterDriver().printImageBase64(imageBase64);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresión enviada",
-                text2: "Documento enviado a la impresora",
+            notifyDevice({
+                name: "printer.sent",
+                title: "Impresión enviada",
+                message: "Documento enviado a la impresora",
+                variant: "success",
             });
             return true;
         }
@@ -233,7 +238,7 @@ class PrinterService {
         if (!printer)
             return false;
         loggerUseCases.info(`Grace reconnect: reconnecting to ${printer.name} (${printer.address})`);
-        return this.connect(printer.address, printer.name);
+        return this.connect(printer.address, printer.name, false);
     }
     async ensureConnected() {
         if (this.isConnected()) {
@@ -241,10 +246,11 @@ class PrinterService {
         }
         const printer = await this.getSelectedPrinter();
         if (!printer) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Sin impresora",
-                text2: "Selecciona una impresora primero",
+            notifyDevice({
+                name: "printer.missing",
+                title: "Sin impresora",
+                message: "Selecciona una impresora primero",
+                variant: "danger",
             });
             return false;
         }

package/dist/tools/utils/date.js

@@ -1,3 +1,4 @@
+import { dayOf, isDay } from "@sincpro/client-framework";
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone";
 import utc from "dayjs/plugin/utc";
@@ -53,7 +54,7 @@ export function formatDate(input, timezone, options) {
     const usedLocale = options?.locale ?? deviceLocale;
     try {
         const rawStr = typeof input === "string" ? input : input.toISOString();
-        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(rawStr);
+        const isDateOnly = typeof input === "string" && isDay(input);
         // Auto-detect showTime si no se pasa explicitamente
         const effectiveShowTime = options?.showTime !== undefined
             ? options.showTime
@@ -100,11 +101,11 @@ export function formatDateWithDefaultTimezone(input, options) {
 export function getCurrentDateInTimezone(timezone) {
     const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
     try {
-        return dayjs().tz(effectiveTimezone).format("YYYY-MM-DD");
+        return dayOf(new Date().toISOString(), effectiveTimezone) ?? dayjs().format("YYYY-MM-DD");
     }
     catch (error) {
         console.warn("Error obteniendo fecha actual en timezone:", error);
-        return dayjs().format("YYYY-MM-DD"); // Fallback to local
+        return dayjs().format("YYYY-MM-DD");
     }
 }
 /**

package/dist/tools/utils/monetary.d.ts

@@ -1,3 +1,6 @@
-export declare function parseToMonetaryNumber(input?: string | number | null): number;
-export declare function formatTwoDecimals(value?: number | string | null): string;
-export declare function calculateDiscountedTotal(total: number, discount: number): number;
+import { Decimal, type DecimalLike } from "@sincpro/client-framework";
+export declare function toDecimal(input?: DecimalLike | null): Decimal;
+export declare function parseToMonetaryNumber(input?: DecimalLike | null): Decimal;
+export declare function formatTwoDecimals(value?: DecimalLike | null): string;
+export declare function discountOf(total: DecimalLike, discount: DecimalLike): Decimal;
+export declare function calculateDiscountedTotal(total: DecimalLike, discount: DecimalLike): Decimal;