@sincpro/mobile 0.4.4 → 1.0.0

package/dist/infrastructure/database/schema.js

@@ -0,0 +1,61 @@
+import { DBCursor } from "../../infrastructure/database/connector";
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const DEFINITION = /^[A-Za-z0-9_ ()'",.{}-]+$/;
+const LEDGER = "schema_migrations";
+export function assertSqlIdentifier(name) {
+    if (!IDENTIFIER.test(name))
+        throw new Error(`invalid SQL identifier: ${name}`);
+}
+export function addColumnStatement(table, column, definition) {
+    assertSqlIdentifier(table);
+    assertSqlIdentifier(column);
+    if (!DEFINITION.test(definition))
+        throw new Error(`invalid column definition: ${definition}`);
+    return `ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`;
+}
+export async function tableColumns(table) {
+    assertSqlIdentifier(table);
+    const rows = await DBCursor.getAllAsync(`PRAGMA table_info(${table})`);
+    return rows.map((row) => row.name);
+}
+export function tableColumnsSync(table) {
+    assertSqlIdentifier(table);
+    const rows = DBCursor.getAllSync(`PRAGMA table_info(${table})`);
+    return rows.map((row) => row.name);
+}
+export async function addColumnIfMissing(table, column, definition) {
+    const existing = await tableColumns(table);
+    if (existing.includes(column))
+        return;
+    await DBCursor.execAsync(addColumnStatement(table, column, definition));
+}
+export function addColumnIfMissingSync(table, column, definition) {
+    const existing = tableColumnsSync(table);
+    if (existing.includes(column))
+        return;
+    DBCursor.mutateDatabaseSync(addColumnStatement(table, column, definition));
+}
+export async function appliedMigrationNames() {
+    await ensureLedger();
+    const rows = await DBCursor.getAllAsync(`SELECT name FROM ${LEDGER}`);
+    return new Set(rows.map((row) => row.name));
+}
+export async function markMigrationApplied(name) {
+    await ensureLedger();
+    await DBCursor.mutateDatabase(`INSERT OR IGNORE INTO ${LEDGER} (name) VALUES (?)`, name);
+}
+export async function forgetMigrations(names) {
+    await ensureLedger();
+    if (names.length === 0)
+        return;
+    const marks = names.map(() => "?").join(", ");
+    await DBCursor.mutateDatabase(`DELETE FROM ${LEDGER} WHERE name IN (${marks})`, ...names);
+}
+async function ensureLedger() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${LEDGER} (
+      name TEXT PRIMARY KEY NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+}

package/dist/infrastructure/database/utils.d.ts

@@ -1,3 +1,5 @@
+import { isEntityId, momentOf } from "@sincpro/client-framework";
+export { isEntityId, momentOf };
 /**
  * Constructs a SQL placeholder string and corresponding values for use in a query based on the provided field and data.
  *

package/dist/infrastructure/database/utils.js

@@ -1,6 +1,7 @@
+import { isEntityId, momentOf, newEntityId } from "@sincpro/client-framework";
 import { convertToArray } from "../../tools/utils/collections";
 import * as Crypto from "expo-crypto";
-import { v7 as uuidv7 } from "uuid";
+export { isEntityId, momentOf };
 /**
  * Constructs a SQL placeholder string and corresponding values for use in a query based on the provided field and data.
  *
@@ -28,8 +29,15 @@ export function getPlaceholders(field, data) {
     }
     return [`${field} IN (${placeholders})`, values];
 }
-export function generateUUID() {
-    return uuidv7({
-        random: Crypto.getRandomBytes(16),
+function ensureRandom() {
+    if (typeof globalThis.crypto?.getRandomValues === "function")
+        return;
+    Object.defineProperty(globalThis, "crypto", {
+        value: { getRandomValues: Crypto.getRandomValues },
+        configurable: true,
     });
 }
+export function generateUUID() {
+    ensureRandom();
+    return newEntityId();
+}

package/dist/infrastructure/event_chain.d.ts

@@ -0,0 +1,6 @@
+import { type Chain } from "../domain/events/chain";
+export declare const EVENT_CHAIN_KEY: import("./context_manager/context_key").ContextKey<Chain>;
+export declare function openChain(active: Chain | undefined): Chain;
+export declare function currentChain(): Chain | undefined;
+export declare function runWithChain<T>(chain: Chain, fn: () => T): T;
+export declare function traceparent(): string | null;

package/dist/infrastructure/event_chain.js

@@ -0,0 +1,25 @@
+import { generateUUID } from "../infrastructure/database/utils";
+import { getActiveSpanContext } from "../infrastructure/telemetry/tracing/active_span";
+import { createContextKey } from "./context_manager/context_key";
+import { getActiveContext, getContext, runWithContext } from "./context_manager/index";
+export const EVENT_CHAIN_KEY = createContextKey("sincpro.event.chain");
+export function openChain(active) {
+    const executionId = generateUUID();
+    if (!active) {
+        return { causationId: executionId, correlationId: executionId };
+    }
+    return { causationId: executionId, correlationId: active.correlationId };
+}
+export function currentChain() {
+    return getContext(EVENT_CHAIN_KEY);
+}
+export function runWithChain(chain, fn) {
+    return runWithContext(getActiveContext().set(EVENT_CHAIN_KEY, chain), fn);
+}
+export function traceparent() {
+    const span = getActiveSpanContext();
+    if (!span)
+        return null;
+    const flags = span.traceFlags.toString(16).padStart(2, "0");
+    return `00-${span.traceId}-${span.spanId}-${flags}`;
+}

package/dist/infrastructure/telemetry/tracing/tracing_hooks.js

@@ -1,5 +1,6 @@
 import { ROOT_CONTEXT as OTEL_ROOT, SpanStatusCode, trace } from "@opentelemetry/api";
 import { _getContextManager } from "../../../infrastructure/context_manager";
+import { EVENT_CHAIN_KEY, openChain } from "../../../infrastructure/event_chain";
 import { OTEL_CTX_KEY } from "../../../infrastructure/telemetry/context_keys";
 const _spanMap = new WeakMap();
 // Tracks whether `before` successfully pushed a context entry for this call.
@@ -19,21 +20,23 @@ const _pushedMap = new WeakSet();
 export function tracingHooks(tracerName) {
     return {
         before(call) {
+            const manager = _getContextManager();
+            let ctx = manager.active();
+            ctx = ctx.set(EVENT_CHAIN_KEY, openChain(ctx.get(EVENT_CHAIN_KEY)));
             try {
-                const manager = _getContextManager();
-                const frameworkCtx = manager.active();
-                const otelCtx = frameworkCtx.get(OTEL_CTX_KEY) ?? OTEL_ROOT;
+                const otelCtx = ctx.get(OTEL_CTX_KEY) ?? OTEL_ROOT;
                 const spanName = call.className
                     ? `${call.className}.${call.methodName}`
                     : call.methodName;
                 const span = trace.getTracer(tracerName).startSpan(spanName, undefined, otelCtx);
                 _spanMap.set(call, span);
-                manager.push(frameworkCtx.set(OTEL_CTX_KEY, trace.setSpan(otelCtx, span)));
-                _pushedMap.add(call);
+                ctx = ctx.set(OTEL_CTX_KEY, trace.setSpan(otelCtx, span));
             }
             catch {
                 _spanMap.delete(call);
             }
+            manager.push(ctx);
+            _pushedMap.add(call);
         },
         after(call) {
             const span = _spanMap.get(call);

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

@@ -3,7 +3,9 @@ declare class UIEventBusImpl {
     private emitter;
     private subscriptions;
     private handlerIdCounter;
-    on<T = unknown>(event: string, handler: Handler<T>): () => void;
+    on<T = unknown>(event: string, handler: Handler<T>, options?: {
+        debounce?: boolean;
+    }): () => void;
     off<T = unknown>(event: string, handler: Handler<T>): void;
     emit<T = unknown>(event: string, payload?: T): void;
     clear(): void;

package/dist/infrastructure/ui/UIEventBus.js

@@ -4,7 +4,14 @@ class UIEventBusImpl {
     emitter = mitt();
     subscriptions = new Map();
     handlerIdCounter = 0;
-    on(event, handler) {
+    on(event, handler, options) {
+        if (options?.debounce === false) {
+            const direct = handler;
+            this.emitter.on(event, direct);
+            return () => {
+                this.emitter.off(event, direct);
+            };
+        }
         const handlerId = `${event}_${++this.handlerIdCounter}`;
         const wrappedHandler = (payload) => {
             const sub = this.subscriptions.get(handlerId);

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

@@ -0,0 +1,37 @@
+import { type LabelText } from "../../domain/events/label";
+export declare const ACTIVITY_EVENT = "ui.activity";
+export declare const ACTIVITY_SETTING_EVENT = "ui.activity.setting";
+export type ActivityChannel = "queue" | "cron" | "device";
+export type ActivityStatus = "running" | "succeeded" | "failed" | "idle";
+export interface ActivityFact {
+    id: string;
+    channel: ActivityChannel;
+    name: string;
+    label: LabelText;
+    detail?: LabelText;
+    status: ActivityStatus;
+    ui: boolean;
+    variant?: "success" | "danger" | "info";
+}
+export interface ActivityState {
+    running: ActivityFact[];
+    failure?: ActivityFact;
+    notices: ActivityFact[];
+}
+export interface ActivitySettingChange {
+    channel: ActivityChannel;
+    enabled: boolean;
+}
+export declare const emptyActivity: ActivityState;
+export declare function declaresUi(source: object): boolean;
+export declare function publishActivity(fact: Omit<ActivityFact, "id">): ActivityFact;
+export declare function notifyDevice(input: {
+    name: string;
+    title: LabelText;
+    message: LabelText;
+    variant: "success" | "danger" | "info";
+}): void;
+export declare function loadActivityEnabled(): Promise<Record<ActivityChannel, boolean>>;
+export declare function setActivityEnabled(channel: ActivityChannel, enabled: boolean): Promise<void>;
+export declare function activityVisible(fact: ActivityFact, enabled: Record<ActivityChannel, boolean>, all?: boolean): boolean;
+export declare function applyActivity(state: ActivityState, fact: ActivityFact): ActivityState;

package/dist/infrastructure/ui/activity.js

@@ -0,0 +1,84 @@
+import { SettingsRepository } from "../../adapters/repositories/setting.repository";
+import { textOf } from "../../domain/events/label";
+import { ECommonSetting } from "../../domain/settings";
+import { UIEventBus } from "./UIEventBus";
+export const ACTIVITY_EVENT = "ui.activity";
+export const ACTIVITY_SETTING_EVENT = "ui.activity.setting";
+export const emptyActivity = { running: [], notices: [] };
+const SETTING_KEY = {
+    queue: ECommonSetting.UI_QUEUE,
+    cron: ECommonSetting.UI_CRON,
+    device: ECommonSetting.UI_DEVICE,
+};
+let sequence = 0;
+export function declaresUi(source) {
+    return source.constructor.ui === true;
+}
+export function publishActivity(fact) {
+    const full = { ...fact, id: `${fact.channel}:${fact.name}:${++sequence}` };
+    UIEventBus.emit(ACTIVITY_EVENT, full);
+    return full;
+}
+export function notifyDevice(input) {
+    publishActivity({
+        channel: "device",
+        name: input.name,
+        label: input.title,
+        detail: input.message,
+        status: input.variant === "danger" ? "failed" : "succeeded",
+        variant: input.variant,
+        ui: true,
+    });
+}
+export async function loadActivityEnabled() {
+    const enabled = {
+        queue: true,
+        cron: true,
+        device: true,
+    };
+    for (const channel of Object.keys(SETTING_KEY)) {
+        try {
+            const value = await SettingsRepository.getSettingByName(SETTING_KEY[channel]);
+            if (value === false)
+                enabled[channel] = false;
+        }
+        catch {
+            return enabled;
+        }
+    }
+    return enabled;
+}
+export async function setActivityEnabled(channel, enabled) {
+    await SettingsRepository.saveOneSetting(SETTING_KEY[channel], enabled);
+    const change = { channel, enabled };
+    UIEventBus.emit(ACTIVITY_SETTING_EVENT, change);
+}
+export function activityVisible(fact, enabled, all = false) {
+    if (all)
+        return true;
+    if (!fact.ui)
+        return false;
+    if (!enabled[fact.channel])
+        return false;
+    if (fact.channel !== "device" && textOf(fact.label).length === 0)
+        return false;
+    return true;
+}
+export function applyActivity(state, fact) {
+    if (fact.channel === "device") {
+        return { ...state, notices: [...state.notices, fact].slice(-8) };
+    }
+    const running = state.running.filter((item) => item.channel !== fact.channel || item.name !== fact.name);
+    const sameFailure = state.failure?.channel === fact.channel && state.failure.name === fact.name;
+    if (fact.status === "running") {
+        return { ...state, running: [...running, fact], failure: undefined };
+    }
+    if (fact.status === "failed") {
+        return { ...state, running, failure: fact };
+    }
+    return {
+        ...state,
+        running,
+        failure: sameFailure ? undefined : state.failure,
+    };
+}

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

@@ -1,8 +1,9 @@
+import { type LabelText } from "../../domain/events/label";
 export type CronJob = () => Promise<void>;
 export interface CronWorkerOpts {
     requiresAuth?: boolean;
-    label?: string;
-    showToast?: boolean;
+    label?: LabelText;
+    ui?: boolean;
 }
 export declare class CronWorker {
     readonly taskName: string;
@@ -13,8 +14,8 @@ export declare class CronWorker {
     private isExecuting;
     private registrationError?;
     readonly requiresAuth: boolean;
-    label?: string;
-    private showToast;
+    label?: LabelText;
+    private ui;
     constructor(taskName: string, job: CronJob, intervalMin?: number, opts?: CronWorkerOpts);
     configure(opts: Partial<CronWorkerOpts>): void;
     /**
@@ -42,6 +43,7 @@ export declare class CronWorker {
     getLastError(): Error | undefined;
     private createIntervalJob;
     private runWithEvents;
+    private publish;
     /**
      * Waits for current job execution to complete (if any).
      * Timeout after 10 seconds to prevent infinite wait.

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