@sincpro/mobile 0.1.0

package/dist/infrastructure/database/utils.js

@@ -0,0 +1,35 @@
+import { convertToArray } from "../../tools/utils/collections";
+import * as Crypto from "expo-crypto";
+import { v7 as uuidv7 } from "uuid";
+/**
+ * Constructs a SQL placeholder string and corresponding values for use in a query based on the provided field and data.
+ *
+ * @param {string} field - The database field name to be used in the placeholder condition.
+ * @param {any} data - The data used to generate placeholders and corresponding values. Can be an array, object, set, or a single value.
+ * @return {[string, string]} - A tuple where the first element is the formatted placeholder condition string,
+ * and the second element is the corresponding values. IE: `["field IN (?, ?, ?)", [value1, value2, value3]]`.
+ */
+export function getPlaceholders(field, data) {
+    let placeholders = "";
+    let values = data;
+    if (data instanceof Set) {
+        values = convertToArray(data);
+        placeholders = values.map(() => "?").join(",");
+    }
+    else if (data instanceof Object) {
+        values = Object.values(data);
+        placeholders = Object.keys(data)
+            .map(() => "?")
+            .join(",");
+    }
+    else {
+        values = convertToArray(data);
+        placeholders = data.map(() => "?").join(",");
+    }
+    return [`${field} IN (${placeholders})`, values];
+}
+export function generateUUID() {
+    return uuidv7({
+        random: Crypto.getRandomBytes(16),
+    });
+}

package/dist/infrastructure/logger.d.ts

@@ -0,0 +1,45 @@
+type LoggerArgs = unknown[];
+interface ILogger {
+    debug(...args: LoggerArgs): void;
+    info(...args: LoggerArgs): void;
+    warn(...args: LoggerArgs): void;
+    error(...args: LoggerArgs): void;
+}
+declare const enum ELogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+declare const enum EApplicationLogger {
+    GLOBAL = "GLOBAL",
+    ODOO_CLIENT = "ODOO_CLIENT",
+    ADAPTER = "ADAPTER",
+    REPOSITORIES = "REPOSITORIES",
+    USE_CASES = "USE_CASES",
+    QUEUE_PROCESSOR = "EVENT_BUS",
+    CRON_JOBS = "CRON_JOBS"
+}
+/**
+ * Production flag - manually toggle to disable all logs
+ * Set to true to disable logging, false to enable
+ */
+export declare const IS_PRODUCTION = false;
+/**
+ * Global log level for the application.
+ */
+export declare const LOG_LEVEL = ELogLevel.INFO;
+/**
+ * Configuration for enabling or disabling logs for specific application contexts.
+ */
+export declare const ENABLED_LOGS: Record<EApplicationLogger, boolean>;
+export declare function createLogger(context: EApplicationLogger): ILogger;
+declare const logger: ILogger;
+export declare const loggerOdooClient: ILogger;
+export declare const loggerAdapter: ILogger;
+export declare const loggerRepositories: ILogger;
+export declare const loggerUseCases: ILogger;
+export declare const loggerQueueProcessor: ILogger;
+export declare const loggerCronJobs: ILogger;
+export { EApplicationLogger };
+export default logger;

package/dist/infrastructure/logger.js

@@ -0,0 +1,125 @@
+// ANSI color codes for terminal output
+const Colors = {
+    Reset: "\x1b[0m",
+    Gray: "\x1b[90m",
+    Red: "\x1b[31m",
+    Yellow: "\x1b[33m",
+    Blue: "\x1b[34m",
+    Cyan: "\x1b[36m",
+    Green: "\x1b[32m",
+    Magenta: "\x1b[35m",
+    BrightBlue: "\x1b[94m",
+    BrightGreen: "\x1b[92m",
+    BrightCyan: "\x1b[96m",
+    BrightMagenta: "\x1b[95m",
+    BrightYellow: "\x1b[93m",
+    White: "\x1b[37m",
+};
+/**
+ * Color mapping for each logger context
+ */
+const LoggerColors = {
+    ["GLOBAL" /* EApplicationLogger.GLOBAL */]: Colors.White,
+    ["ODOO_CLIENT" /* EApplicationLogger.ODOO_CLIENT */]: Colors.Gray,
+    ["ADAPTER" /* EApplicationLogger.ADAPTER */]: Colors.Gray,
+    ["REPOSITORIES" /* EApplicationLogger.REPOSITORIES */]: Colors.Gray,
+    ["USE_CASES" /* EApplicationLogger.USE_CASES */]: Colors.BrightGreen,
+    ["EVENT_BUS" /* EApplicationLogger.QUEUE_PROCESSOR */]: Colors.BrightYellow,
+    ["CRON_JOBS" /* EApplicationLogger.CRON_JOBS */]: Colors.Gray,
+};
+/**
+ * Production flag - manually toggle to disable all logs
+ * Set to true to disable logging, false to enable
+ */
+export const IS_PRODUCTION = false;
+/**
+ * Global log level for the application.
+ */
+export const LOG_LEVEL = "INFO" /* ELogLevel.INFO */;
+/**
+ * Configuration for enabling or disabling logs for specific application contexts.
+ */
+export const ENABLED_LOGS = {
+    ["GLOBAL" /* EApplicationLogger.GLOBAL */]: true,
+    ["ODOO_CLIENT" /* EApplicationLogger.ODOO_CLIENT */]: false,
+    ["ADAPTER" /* EApplicationLogger.ADAPTER */]: false,
+    ["REPOSITORIES" /* EApplicationLogger.REPOSITORIES */]: false,
+    ["USE_CASES" /* EApplicationLogger.USE_CASES */]: true,
+    ["EVENT_BUS" /* EApplicationLogger.QUEUE_PROCESSOR */]: true,
+    ["CRON_JOBS" /* EApplicationLogger.CRON_JOBS */]: true,
+};
+class BaseLogger {
+    context;
+    contextPrefix;
+    constructor(context) {
+        this.context = context;
+        this.contextPrefix = context === "GLOBAL" /* EApplicationLogger.GLOBAL */ ? "" : `[${context}]`;
+    }
+    getLogColor(level) {
+        switch (level) {
+            case "DEBUG" /* ELogLevel.DEBUG */:
+                return Colors.Gray;
+            case "INFO" /* ELogLevel.INFO */:
+                return Colors.Cyan;
+            case "WARN" /* ELogLevel.WARN */:
+                return Colors.Yellow;
+            case "ERROR" /* ELogLevel.ERROR */:
+                return Colors.Red;
+            default:
+                return Colors.White;
+        }
+    }
+    getContextColor() {
+        return LoggerColors[this.context];
+    }
+    log(level, method, args) {
+        if (this.shouldLog(level)) {
+            this.output(method, level, args);
+        }
+    }
+    shouldLog(level) {
+        if (IS_PRODUCTION)
+            return false;
+        if (level === "ERROR" /* ELogLevel.ERROR */ || level === "WARN" /* ELogLevel.WARN */)
+            return true;
+        if (level === "DEBUG" /* ELogLevel.DEBUG */ && LOG_LEVEL !== "DEBUG" /* ELogLevel.DEBUG */)
+            return false;
+        if (!ENABLED_LOGS[this.context])
+            return false;
+        return true;
+    }
+    output(method, level, args) {
+        const timestamp = new Date().toISOString();
+        const contextColor = this.getContextColor();
+        if (this.contextPrefix) {
+            // Colorear todo el mensaje con el color del contexto
+            method(`${Colors.Gray}${timestamp}${Colors.Reset}`, `${contextColor}${this.contextPrefix}`, ...args, Colors.Reset);
+        }
+        else {
+            method(`${Colors.Gray}${timestamp}${Colors.Reset}`, ...args);
+        }
+    }
+    debug(...args) {
+        this.log("DEBUG" /* ELogLevel.DEBUG */, console.debug, args);
+    }
+    info(...args) {
+        this.log("INFO" /* ELogLevel.INFO */, console.log, args);
+    }
+    warn(...args) {
+        this.log("WARN" /* ELogLevel.WARN */, console.warn, args);
+    }
+    error(...args) {
+        this.log("ERROR" /* ELogLevel.ERROR */, console.error, args);
+    }
+}
+export function createLogger(context) {
+    return new BaseLogger(context);
+}
+const logger = createLogger("GLOBAL" /* EApplicationLogger.GLOBAL */);
+export const loggerOdooClient = createLogger("ODOO_CLIENT" /* EApplicationLogger.ODOO_CLIENT */);
+export const loggerAdapter = createLogger("ADAPTER" /* EApplicationLogger.ADAPTER */);
+export const loggerRepositories = createLogger("REPOSITORIES" /* EApplicationLogger.REPOSITORIES */);
+export const loggerUseCases = createLogger("USE_CASES" /* EApplicationLogger.USE_CASES */);
+export const loggerQueueProcessor = createLogger("EVENT_BUS" /* EApplicationLogger.QUEUE_PROCESSOR */);
+export const loggerCronJobs = createLogger("CRON_JOBS" /* EApplicationLogger.CRON_JOBS */);
+export default logger;

package/dist/infrastructure/ui/ToastHost.d.ts

@@ -0,0 +1 @@
+export declare function ToastHost(): import("react/jsx-runtime").JSX.Element;

package/dist/infrastructure/ui/ToastHost.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { useEffect } from "react";
+import Toast from "react-native-toast-message";
+import { UI_NOTIFICATION_EVENT } from "./events";
+import { UIEventBus } from "./UIEventBus";
+export function ToastHost() {
+    useEffect(() => {
+        const off = UIEventBus.on(UI_NOTIFICATION_EVENT, (payload) => {
+            const notification = payload;
+            Toast.show({
+                type: notification.type ?? "info",
+                text1: notification.text1,
+                text2: notification.text2,
+            });
+        });
+        return off;
+    }, []);
+    return _jsx(Toast, {});
+}

package/dist/infrastructure/ui/UIEventBus.d.ts

@@ -0,0 +1,12 @@
+import { Handler } from "mitt";
+declare class UIEventBusImpl {
+    private emitter;
+    private subscriptions;
+    private handlerIdCounter;
+    on<T = unknown>(event: string, handler: Handler<T>): () => void;
+    off<T = unknown>(event: string, handler: Handler<T>): void;
+    emit<T = unknown>(event: string, payload?: T): void;
+    clear(): void;
+}
+export declare const UIEventBus: UIEventBusImpl;
+export {};

package/dist/infrastructure/ui/UIEventBus.js

@@ -0,0 +1,65 @@
+import mitt from "mitt";
+const DEBOUNCE_DELAY = 300;
+class UIEventBusImpl {
+    emitter = mitt();
+    subscriptions = new Map();
+    handlerIdCounter = 0;
+    on(event, handler) {
+        const handlerId = `${event}_${++this.handlerIdCounter}`;
+        const wrappedHandler = (payload) => {
+            const sub = this.subscriptions.get(handlerId);
+            if (sub?.timer) {
+                clearTimeout(sub.timer);
+            }
+            const timer = setTimeout(() => {
+                handler(payload);
+                const subscription = this.subscriptions.get(handlerId);
+                if (subscription)
+                    subscription.timer = null;
+            }, DEBOUNCE_DELAY);
+            this.subscriptions.set(handlerId, {
+                timer,
+                wrappedHandler,
+                originalHandler: handler,
+            });
+        };
+        this.subscriptions.set(handlerId, {
+            timer: null,
+            wrappedHandler,
+            originalHandler: handler,
+        });
+        this.emitter.on(event, wrappedHandler);
+        return () => {
+            const sub = this.subscriptions.get(handlerId);
+            if (sub?.timer)
+                clearTimeout(sub.timer);
+            if (sub?.wrappedHandler)
+                this.emitter.off(event, sub.wrappedHandler);
+            this.subscriptions.delete(handlerId);
+        };
+    }
+    off(event, handler) {
+        for (const [handlerId, sub] of this.subscriptions.entries()) {
+            if (handlerId.startsWith(`${event}_`) && sub.originalHandler === handler) {
+                if (sub.timer)
+                    clearTimeout(sub.timer);
+                this.emitter.off(event, sub.wrappedHandler);
+                this.subscriptions.delete(handlerId);
+                return;
+            }
+        }
+        this.emitter.off(event, handler);
+    }
+    emit(event, payload) {
+        this.emitter.emit(event, payload);
+    }
+    clear() {
+        this.subscriptions.forEach((sub) => {
+            if (sub.timer)
+                clearTimeout(sub.timer);
+        });
+        this.subscriptions.clear();
+        this.emitter.all.clear();
+    }
+}
+export const UIEventBus = new UIEventBusImpl();

package/dist/infrastructure/ui/errorHandler.d.ts

@@ -0,0 +1 @@
+export declare function installGlobalErrorHandler(): void;

package/dist/infrastructure/ui/errorHandler.js

@@ -0,0 +1,20 @@
+import { DomainException } from "../../exceptions";
+import { Alert } from "react-native";
+export function installGlobalErrorHandler() {
+    const errorUtils = globalThis.ErrorUtils;
+    if (!errorUtils?.setGlobalHandler) {
+        return;
+    }
+    const defaultHandler = errorUtils.getGlobalHandler
+        ? errorUtils.getGlobalHandler()
+        : errorUtils._globalHandler;
+    errorUtils.setGlobalHandler((error, isFatal) => {
+        if (error instanceof DomainException) {
+            Alert.alert("Error", error.message, [{ text: "OK" }], { cancelable: true });
+            return;
+        }
+        if (typeof defaultHandler === "function") {
+            defaultHandler(error, isFatal);
+        }
+    });
+}

package/dist/infrastructure/ui/events.d.ts

@@ -0,0 +1 @@
+export declare const UI_NOTIFICATION_EVENT = "ui.notification";

package/dist/infrastructure/ui/events.js

@@ -0,0 +1 @@
+export const UI_NOTIFICATION_EVENT = "ui.notification";

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

@@ -0,0 +1,42 @@
+export type CronJob = () => Promise<void>;
+export declare class CronWorker {
+    readonly taskName: string;
+    private readonly job;
+    private readonly intervalMin;
+    readonly requiresAuth: boolean;
+    private stopFn?;
+    private isRegistering;
+    private isExecuting;
+    private registrationError?;
+    constructor(taskName: string, job: CronJob, intervalMin?: number, requiresAuth?: boolean);
+    /**
+     * Registers a task with a specified interval and execution logic.
+     * If the interval is less than 15 minutes, a repeating job is created using a defined stop function.
+     * If the interval is 15 minutes or greater, the task is registered with a task manager and scheduled as a background task.
+     *
+     * @return {Promise<void>} A promise that resolves when the task registration process is complete.
+     */
+    start(): Promise<void>;
+    /**
+     * Unregisters a background task with the specified task name.
+     * If a stop function is defined, it is invoked before unregistering the task.
+     *
+     * @return {Promise<void>} A promise that resolves when the task has been successfully unregistered.
+     */
+    unregister(): Promise<void>;
+    /**
+     * Check if the task is properly registered and functioning
+     */
+    isHealthy(): boolean;
+    /**
+     * Get any registration error that occurred
+     */
+    getLastError(): Error | undefined;
+    private createIntervalJob;
+    private runWithEvents;
+    /**
+     * Waits for current job execution to complete (if any).
+     * Timeout after 10 seconds to prevent infinite wait.
+     */
+    waitForIdle(): Promise<void>;
+}

package/dist/infrastructure/workers/CronWorker.js

@@ -0,0 +1,143 @@
+import { loggerCronJobs } from "../../infrastructure/logger";
+import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
+import * as BackgroundTask from "expo-background-task";
+import * as TaskManager from "expo-task-manager";
+export class CronWorker {
+    taskName;
+    job;
+    intervalMin;
+    requiresAuth;
+    stopFn;
+    isRegistering = false;
+    isExecuting = false;
+    registrationError;
+    constructor(taskName, job, intervalMin = 15, requiresAuth = false) {
+        this.taskName = taskName;
+        this.job = job;
+        this.intervalMin = intervalMin;
+        this.requiresAuth = requiresAuth;
+    }
+    /**
+     * Registers a task with a specified interval and execution logic.
+     * If the interval is less than 15 minutes, a repeating job is created using a defined stop function.
+     * If the interval is 15 minutes or greater, the task is registered with a task manager and scheduled as a background task.
+     *
+     * @return {Promise<void>} A promise that resolves when the task registration process is complete.
+     */
+    async start() {
+        if (this.isRegistering)
+            return;
+        this.isRegistering = true;
+        try {
+            loggerCronJobs.info(`Schedule [every ${this.intervalMin} min]: task ${this.taskName}`);
+            if (this.intervalMin < 15) {
+                this.stopFn = this.createIntervalJob(this.job, this.intervalMin);
+            }
+            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;
+                    }
+                });
+                await BackgroundTask.registerTaskAsync(this.taskName, {
+                    minimumInterval: this.intervalMin,
+                });
+            }
+            this.registrationError = undefined;
+        }
+        catch (error) {
+            this.registrationError = error instanceof Error ? error : new Error(String(error));
+            loggerCronJobs.warn(`Failed to register task ${this.taskName}:`, error);
+            throw error;
+        }
+        finally {
+            this.isRegistering = false;
+        }
+    }
+    /**
+     * Unregisters a background task with the specified task name.
+     * If a stop function is defined, it is invoked before unregistering the task.
+     *
+     * @return {Promise<void>} A promise that resolves when the task has been successfully unregistered.
+     */
+    async unregister() {
+        try {
+            if (this.stopFn) {
+                this.stopFn();
+                this.stopFn = undefined;
+            }
+            // Only attempt to unregister background tasks (>= 15 min)
+            if (this.intervalMin >= 15) {
+                await BackgroundTask.unregisterTaskAsync(this.taskName);
+            }
+            loggerCronJobs.info(`Task ${this.taskName} unregistered successfully`);
+        }
+        catch (error) {
+            loggerCronJobs.warn(`Failed to unregister task ${this.taskName}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Check if the task is properly registered and functioning
+     */
+    isHealthy() {
+        return !this.registrationError && (this.stopFn !== undefined || this.intervalMin >= 15);
+    }
+    /**
+     * Get any registration error that occurred
+     */
+    getLastError() {
+        return this.registrationError;
+    }
+    createIntervalJob(job, intervalMinutes) {
+        this.runWithEvents(job);
+        const id = setInterval(() => {
+            this.runWithEvents(job);
+        }, intervalMinutes * 60 * 1000);
+        return () => {
+            clearInterval(id);
+        };
+    }
+    async runWithEvents(job) {
+        this.isExecuting = true;
+        const startTime = Date.now();
+        UIEventBus.emit("CRON_START", { task: this.taskName });
+        try {
+            await Promise.resolve(job());
+            const duration = Date.now() - startTime;
+            loggerCronJobs.debug(`${this.taskName} completed successfully in ${duration}ms`);
+        }
+        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}`);
+        }
+        finally {
+            this.isExecuting = false;
+            UIEventBus.emit("CRON_END", { task: this.taskName });
+        }
+    }
+    /**
+     * Waits for current job execution to complete (if any).
+     * Timeout after 10 seconds to prevent infinite wait.
+     */
+    async waitForIdle() {
+        if (!this.isExecuting)
+            return;
+        const maxWait = 10000;
+        const checkInterval = 100;
+        let waited = 0;
+        while (this.isExecuting && waited < maxWait) {
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        if (this.isExecuting) {
+            loggerCronJobs.warn(`${this.taskName} waitForIdle timed out after 10s`);
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+import { DomainEvent, EventName, Subscriber } from "../../domain/event_sourcing";
+export declare const PROCESS_WORKER_MAX_ATTEMPTS = 1;
+export { EventName };
+export declare class EventBus {
+    private static readonly MAX_ATTEMPTS;
+    private static readonly INTERVAL_MS;
+    private static readonly MAX_INTERVAL_MS;
+    private static readonly BACKOFF_MULTIPLIER;
+    private static subscribers;
+    private static isDraining;
+    private static intervalId;
+    private static internetConnected;
+    private static consecutiveFailures;
+    private static currentInterval;
+    static initConnectivityListeners(): void;
+    private static adjustInterval;
+    private static restartPolling;
+    private static triggerProcessing;
+    static start(): void;
+    static stop(): void;
+    /**
+     * Waits for current processing cycle to complete (if any).
+     * Use before clean() to ensure graceful shutdown.
+     * Timeout after 5 seconds to prevent infinite wait.
+     */
+    static waitForIdle(): Promise<void>;
+    /**
+     * Validates event, logs start, emits START.
+     * Returns false if no subscribers (caller should return early).
+     */
+    private static preProcess;
+    /**
+     * Handles persistence, emits event and END, logs result.
+     * If errors is empty -> success, otherwise -> failure + dead letter + throws.
+     * @throws Error if there are any errors
+     */
+    private static postProcess;
+    private static executeSubscribers;
+    /**
+     * Registers a subscriber for DomainEvent classes.
+     * A subscriber can listen to multiple events.
+     * Multiple subscribers can listen to the same event.
+     * Prevents duplicate registration of the same subscriber instance.
+     */
+    static on(subscriber: Subscriber): void;
+    static off(subscriber: Subscriber): void;
+    /**
+     * Publishes a DomainEvent asynchronously - enqueues for later processing.
+     */
+    static publish(event: DomainEvent): 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>;
+    /**
+     * Processes all pending DomainEvents from the domain_events table.
+     * Executes ALL subscribers registered for each event.
+     * Moves to dead letter queue on failure.
+     */
+    private static drainAll;
+    /**
+     * Clears the event queue (domain_events table).
+     */
+    static clearQueue(): Promise<void>;
+}