@sincpro/mobile 0.4.1 → 0.4.2

package/dist/entrypoints/cron/EBuiltinCron.d.ts

@@ -0,0 +1,4 @@
+export declare enum EBuiltinCron {
+    CHECK_NETWORK = "CHECK_NETWORK",
+    TELEMETRY_FLUSH = "TELEMETRY_FLUSH"
+}

package/dist/entrypoints/cron/EBuiltinCron.js

@@ -0,0 +1,5 @@
+export var EBuiltinCron;
+(function (EBuiltinCron) {
+    EBuiltinCron["CHECK_NETWORK"] = "CHECK_NETWORK";
+    EBuiltinCron["TELEMETRY_FLUSH"] = "TELEMETRY_FLUSH";
+})(EBuiltinCron || (EBuiltinCron = {}));

package/dist/entrypoints/cron/checkNetworkStatus.cron.js

@@ -1,3 +1,4 @@
+import { EBuiltinCron } from "../../entrypoints/cron/EBuiltinCron";
 import { loggerCronJobs } from "../../infrastructure/logger";
 import { CronWorker } from "../../infrastructure/workers";
 import { networkUseCases } from "../../services/network.service";
@@ -6,5 +7,5 @@ async function checkNetworkStatus() {
     await networkUseCases.getNetworkStatus();
     loggerCronJobs.info("Finished checking network status");
 }
-const cronCheckNetworkStatus = new CronWorker("CHECK_NETWORK", checkNetworkStatus, 2.5);
+const cronCheckNetworkStatus = new CronWorker(EBuiltinCron.CHECK_NETWORK, checkNetworkStatus, 2.5);
 export default cronCheckNetworkStatus;

package/dist/entrypoints/db/migrations.js

@@ -155,23 +155,6 @@ async function createSpansQueueTable() {
     ON ${DATABASE_TABLES.SPANS_QUEUE}(trace_id);
   `);
 }
-// Adds events and links columns to spans_queue for existing installs.
-// Fresh installs get them from createSpansQueueTable above; ALTER TABLE is a
-// no-op on those (caught and ignored — duplicate column error is expected).
-async function addSpansQueueEventsLinks() {
-    try {
-        await DBCursor.execAsync(`ALTER TABLE ${DATABASE_TABLES.SPANS_QUEUE} ADD COLUMN events TEXT NOT NULL DEFAULT '[]'`);
-    }
-    catch {
-        // column already exists on fresh installs
-    }
-    try {
-        await DBCursor.execAsync(`ALTER TABLE ${DATABASE_TABLES.SPANS_QUEUE} ADD COLUMN links TEXT NOT NULL DEFAULT '[]'`);
-    }
-    catch {
-        // column already exists on fresh installs
-    }
-}
 const MIGRATIONS = [
     { name: DATABASE_TABLES.SETTINGS, migrationFn: createSettingsTable },
     { name: DATABASE_TABLES.EVENT_QUEUE, migrationFn: createEventQueueTable },
@@ -183,6 +166,5 @@ const MIGRATIONS = [
     },
     { name: DATABASE_TABLES.TELEMETRY_QUEUE, migrationFn: createTelemetryQueueTable },
     { name: DATABASE_TABLES.SPANS_QUEUE, migrationFn: createSpansQueueTable },
-    { name: "spans_queue_v2_events_links", migrationFn: addSpansQueueEventsLinks },
 ];
 export default MIGRATIONS;

package/dist/entrypoints/ui/common_provider.js

@@ -191,12 +191,12 @@ export function CommonProvider({ children, lightTheme, darkTheme }) {
         function handleCronStart(payload) {
             if (!payload || typeof payload !== "object" || !("task" in payload))
                 return;
-            const { task } = payload;
+            const { task, label } = payload;
             setCronTasks((prev) => {
                 const next = new Map(prev);
                 next.set(task, {
                     id: task,
-                    label: task,
+                    label: label ?? task,
                     type: "cron",
                     status: "running",
                     startedAt: Date.now(),

package/dist/framework/createApp.d.ts

@@ -1,4 +1,5 @@
 import type { TelemetryConfig } from "../infrastructure/telemetry";
+import type { CronWorkerOpts } from "../infrastructure/workers";
 import type { DomainModule } from "./domain_module";
 import { Kernel } from "./kernel";
 export interface AppConfig {
@@ -8,5 +9,12 @@ export interface AppConfig {
      * after migrations complete — so the `telemetry_queue` table is guaranteed to exist.
      */
     telemetry?: TelemetryConfig;
+    /**
+     * Override display options for any cron by taskName.
+     * Useful for showing/hiding toasts on internal crons (CHECK_NETWORK, TELEMETRY_FLUSH, etc.).
+     * @example
+     * crons: { CHECK_NETWORK: { showToast: true, label: "Verificando conexión" } }
+     */
+    crons?: Record<string, Partial<CronWorkerOpts>>;
 }
 export declare function createApp(config?: AppConfig): Promise<Kernel>;

package/dist/framework/createApp.js

@@ -4,8 +4,10 @@ import { Kernel } from "./kernel";
 import { orchestrator } from "./orchestrator";
 export async function createApp(config = {}) {
     const kernel = new Kernel([baseModule, ...(config.domains ?? [])]);
+    if (config.crons)
+        kernel.applyCronConfig(config.crons);
     orchestrator.configure(kernel);
-    await orchestrator.bootstrap(); // migrations run here — telemetry_queue is ready
+    await orchestrator.bootstrap();
     if (config.telemetry) {
         await initTelemetry(config.telemetry);
     }

package/dist/framework/kernel.d.ts

@@ -1,6 +1,6 @@
 import type { IMigration } from "../domain/database";
 import type { Subscriber } from "../domain/event_sourcing";
-import type { CronWorker } from "../infrastructure/workers";
+import type { CronWorker, CronWorkerOpts } from "../infrastructure/workers";
 import type { DomainModule } from "./domain_module";
 export declare class Kernel {
     private readonly modules;
@@ -12,6 +12,7 @@ export declare class Kernel {
     persistedTables(): string[];
     subscribersByKey(): Record<string, Subscriber[]>;
     cronsByKey(): Record<string, CronWorker[]>;
+    applyCronConfig(config: Record<string, Partial<CronWorkerOpts>>): void;
     runMigrations(): Promise<void>;
     bootstrap(): Promise<void>;
     restartDatabase(): Promise<void>;

package/dist/framework/kernel.js

@@ -36,6 +36,14 @@ export class Kernel {
         }
         return map;
     }
+    applyCronConfig(config) {
+        for (const crons of Object.values(this.cronsByKey())) {
+            for (const cron of crons) {
+                if (config[cron.taskName])
+                    cron.configure(config[cron.taskName]);
+            }
+        }
+    }
     async runMigrations() {
         for (const { name, migrationFn } of this.migrations()) {
             logger.info(`Running migration: ${name}`);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { EBuiltinCron } from "./entrypoints/cron/EBuiltinCron";
 export type { AppShellConfig } from "./entrypoints/ui/AppShell";
 export { createAppShell } from "./entrypoints/ui/AppShell";
 export type { TimezoneLocale } from "./entrypoints/ui/common_provider";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { EBuiltinCron } from "./entrypoints/cron/EBuiltinCron";
 export { createAppShell } from "./entrypoints/ui/AppShell";
 export { CommonProvider, useCommon } from "./entrypoints/ui/common_provider";
 export { ActiveDomainApp, DomainSwitcherProvider, useDomainSwitcher, } from "./entrypoints/ui/domain_switcher";

package/dist/infrastructure/telemetry/telemetry_flush_worker.js

@@ -1,6 +1,7 @@
 import { InternetIsDownEvent, InternetIsUpEvent, } from "../../domain/connectivity/events";
+import { EBuiltinCron } from "../../entrypoints/cron/EBuiltinCron";
 import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
-import { CronWorker } from "../../infrastructure/workers/CronWorker";
+import { CronWorker } from "../../infrastructure/workers";
 /** Default background-flush interval (minutes). ≥15 → real OS background task. */
 export const DEFAULT_BACKGROUND_INTERVAL_MIN = 15;
 /**
@@ -49,7 +50,7 @@ export class TelemetryFlushWorker {
         // offline backlog drains promptly when the OS runs the task.
         const intervalMin = this.opts.backgroundIntervalMin ?? DEFAULT_BACKGROUND_INTERVAL_MIN;
         if (intervalMin > 0) {
-            this.cron = new CronWorker("TELEMETRY_FLUSH", () => this.flush.run({ resetBackoff: true }), intervalMin);
+            this.cron = new CronWorker(EBuiltinCron.TELEMETRY_FLUSH, () => this.flush.run({ resetBackoff: true }), intervalMin);
             this.cron.start().catch(() => { });
         }
     }

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

@@ -1,14 +1,22 @@
 export type CronJob = () => Promise<void>;
+export interface CronWorkerOpts {
+    requiresAuth?: boolean;
+    label?: string;
+    showToast?: boolean;
+}
 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);
+    readonly requiresAuth: boolean;
+    label?: string;
+    private showToast;
+    constructor(taskName: string, job: CronJob, intervalMin?: number, opts?: CronWorkerOpts);
+    configure(opts: Partial<CronWorkerOpts>): void;
     /**
      * 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.

package/dist/infrastructure/workers/CronWorker.js

@@ -6,16 +6,26 @@ export class CronWorker {
     taskName;
     job;
     intervalMin;
-    requiresAuth;
     stopFn;
     isRegistering = false;
     isExecuting = false;
     registrationError;
-    constructor(taskName, job, intervalMin = 15, requiresAuth = false) {
+    requiresAuth;
+    label;
+    showToast;
+    constructor(taskName, job, intervalMin = 15, opts = {}) {
         this.taskName = taskName;
         this.job = job;
         this.intervalMin = intervalMin;
-        this.requiresAuth = requiresAuth;
+        this.requiresAuth = opts.requiresAuth ?? false;
+        this.label = opts.label;
+        this.showToast = opts.showToast ?? false;
+    }
+    configure(opts) {
+        if (opts.label !== undefined)
+            this.label = opts.label;
+        if (opts.showToast !== undefined)
+            this.showToast = opts.showToast;
     }
     /**
      * Registers a task with a specified interval and execution logic.
@@ -106,7 +116,9 @@ export class CronWorker {
     async runWithEvents(job) {
         this.isExecuting = true;
         const startTime = Date.now();
-        UIEventBus.emit("CRON_START", { task: this.taskName });
+        if (this.showToast) {
+            UIEventBus.emit("CRON_START", { task: this.taskName, label: this.label });
+        }
         try {
             await Promise.resolve(job());
             const duration = Date.now() - startTime;
@@ -119,7 +131,8 @@ export class CronWorker {
         }
         finally {
             this.isExecuting = false;
-            UIEventBus.emit("CRON_END", { task: this.taskName });
+            if (this.showToast)
+                UIEventBus.emit("CRON_END", { task: this.taskName });
         }
     }
     /**

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

@@ -1,2 +1,2 @@
-export { CronJob, CronWorker } from "./CronWorker";
+export { CronJob, CronWorker, CronWorkerOpts } from "./CronWorker";
 export { EventBus, EventName } from "./EventBus";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sincpro/mobile",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Sincpro Mobile framework core: offline-first infra (DB, queue/events, cron), DDD patterns, adapters, AppShell and module-driven composition for React Native",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -27,6 +27,7 @@
   "author": "Gutierrez, Andres <andres.gutierrez@sincpro.com.bo>",
   "license": "MIT",
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.8.0",
     "@opentelemetry/resources": "^2.8.0",
     "@opentelemetry/sdk-trace-base": "^2.8.0",
@@ -39,7 +40,6 @@
     "uuid": "^13.0.0"
   },
   "peerDependencies": {
-    "@opentelemetry/api": ">=1.3.0 <1.10.0",
     "@react-navigation/native": ">=7",
     "@react-navigation/native-stack": ">=7",
     "@sincpro/mobile-ui": "^0.7.2",