@sincpro/mobile 0.4.3 → 1.0.0

package/dist/infrastructure/workers/CronWorker.js

@@ -1,5 +1,5 @@
 import { loggerCronJobs } from "../../infrastructure/logger";
-import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
+import { publishActivity } from "../../infrastructure/ui/activity";
 import * as BackgroundTask from "expo-background-task";
 import * as TaskManager from "expo-task-manager";
 export class CronWorker {
@@ -12,20 +12,20 @@ export class CronWorker {
     registrationError;
     requiresAuth;
     label;
-    showToast;
+    ui;
     constructor(taskName, job, intervalMin = 15, opts = {}) {
         this.taskName = taskName;
         this.job = job;
         this.intervalMin = intervalMin;
         this.requiresAuth = opts.requiresAuth ?? false;
         this.label = opts.label;
-        this.showToast = opts.showToast ?? false;
+        this.ui = opts.ui ?? false;
     }
     configure(opts) {
         if (opts.label !== undefined)
             this.label = opts.label;
-        if (opts.showToast !== undefined)
-            this.showToast = opts.showToast;
+        if (opts.ui !== undefined)
+            this.ui = opts.ui;
     }
     /**
      * Registers a task with a specified interval and execution logic.
@@ -45,14 +45,10 @@ export class CronWorker {
             }
             else {
                 TaskManager.defineTask(this.taskName, async () => {
-                    try {
-                        await this.job();
-                        return BackgroundTask.BackgroundTaskResult.Success;
-                    }
-                    catch (e) {
-                        loggerCronJobs.warn(`${this.taskName} error:`, e);
-                        return BackgroundTask.BackgroundTaskResult.Failed;
-                    }
+                    const ok = await this.runWithEvents(this.job);
+                    return ok
+                        ? BackgroundTask.BackgroundTaskResult.Success
+                        : BackgroundTask.BackgroundTaskResult.Failed;
                 });
                 await BackgroundTask.registerTaskAsync(this.taskName, {
                     minimumInterval: this.intervalMin,
@@ -116,25 +112,35 @@ export class CronWorker {
     async runWithEvents(job) {
         this.isExecuting = true;
         const startTime = Date.now();
-        if (this.showToast) {
-            UIEventBus.emit("CRON_START", { task: this.taskName, label: this.label });
-        }
+        this.publish("running");
         try {
             await Promise.resolve(job());
             const duration = Date.now() - startTime;
             loggerCronJobs.debug(`${this.taskName} completed successfully in ${duration}ms`);
+            this.publish("succeeded");
+            return true;
         }
         catch (e) {
             const duration = Date.now() - startTime;
             const errorMessage = e instanceof Error ? e.message : String(e);
             loggerCronJobs.error(`${this.taskName} failed after ${duration}ms with error: ${errorMessage}`);
+            this.publish("failed", errorMessage);
+            return false;
         }
         finally {
             this.isExecuting = false;
-            if (this.showToast)
-                UIEventBus.emit("CRON_END", { task: this.taskName });
         }
     }
+    publish(status, detail) {
+        publishActivity({
+            channel: "cron",
+            name: this.taskName,
+            label: this.label ?? this.taskName,
+            detail,
+            status,
+            ui: this.ui,
+        });
+    }
     /**
      * Waits for current job execution to complete (if any).
      * Timeout after 10 seconds to prevent infinite wait.

package/dist/infrastructure/workers/EventBus.d.ts

@@ -1,4 +1,5 @@
-import { DomainEvent, EventName, Subscriber } from "../../domain/event_sourcing";
+import { EventName, type IntegrationEvent } from "../../domain/events";
+import { Subscriber } from "../../event_driven";
 export declare const PROCESS_WORKER_MAX_ATTEMPTS = 1;
 export { EventName };
 export declare class EventBus {
@@ -8,6 +9,7 @@ export declare class EventBus {
     private static readonly BACKOFF_MULTIPLIER;
     private static subscribers;
     private static isDraining;
+    private static connectivityReady;
     private static intervalId;
     private static internetConnected;
     private static consecutiveFailures;
@@ -25,12 +27,12 @@ export declare class EventBus {
      */
     static waitForIdle(): Promise<void>;
     /**
-     * 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).
      */
     private static preProcess;
     /**
-     * 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
      */
@@ -47,13 +49,14 @@ export declare class EventBus {
     /**
      * Publishes a DomainEvent asynchronously - enqueues for later processing.
      */
-    static publish(event: DomainEvent): Promise<void>;
+    static schedule(): void;
+    static publish(event: IntegrationEvent): Promise<void>;
     /**
      * Publishes a DomainEvent synchronously - executes all subscribers immediately.
      * Saves event to DB for traceability. Moves to dead letter on failure.
      * @throws Error if any subscriber fails or no subscribers registered
      */
-    static publishSync(event: DomainEvent): Promise<void>;
+    static publishSync(event: IntegrationEvent): Promise<void>;
     /**
      * Processes all pending DomainEvents from the domain_events table.
      * Executes ALL subscribers registered for each event.
@@ -64,4 +67,5 @@ export declare class EventBus {
      * Clears the event queue (domain_events table).
      */
     static clearQueue(): Promise<void>;
+    private static publishQueue;
 }

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>;