@sincpro/mobile 0.4.3 → 1.0.0

package/dist/adapters/repositories/domain_event.repository.js

@@ -1,21 +1,15 @@
-import { DomainEvent, EEventStatus } from "../../domain/event_sourcing";
+import { EEventStatus } from "../../domain/events";
 import { ECommonRepository } from "../../domain/repositories";
 import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
 import { DBCursor } from "../../infrastructure/database";
 import { loggerRepositories } from "../../infrastructure/logger";
+import { readEvent } from "./event_row";
+const STORED_COLUMNS = "data, status, attempts, error_message, acknowledged_at, failed_at, source_id, sequence, requires_network";
 class DomainEventRepositoryImpl {
     name = ECommonRepository.DOMAIN_EVENT;
     table = DATABASE_TABLES.DOMAIN_EVENTS;
     async hasPendingDuplicate(event) {
-        if (event.correlationId) {
-            const existing = await DBCursor.getFirstAsync(`SELECT uuid FROM ${this.table} 
-         WHERE name = ? AND correlation_id = ? AND status = ?
-         LIMIT 1`, event.name, event.correlationId, EEventStatus.PENDING);
-            return existing !== null;
-        }
-        const existing = await DBCursor.getFirstAsync(`SELECT uuid FROM ${this.table} 
-       WHERE name = ? AND status = ? AND correlation_id IS NULL
-       LIMIT 1`, event.name, EEventStatus.PENDING);
+        const existing = await DBCursor.getFirstAsync(`SELECT uuid FROM ${this.table} WHERE uuid = ? AND status = ? LIMIT 1`, event.uuid, EEventStatus.PENDING);
         return existing !== null;
     }
     async save(event) {
@@ -37,64 +31,64 @@ class DomainEventRepositoryImpl {
         }
     }
     async findById(uuid) {
-        const row = await DBCursor.getFirstAsync(`SELECT data FROM ${this.table} WHERE uuid = ?`, uuid);
-        return row ? DomainEvent.fromJSON(row.data) : null;
+        const row = await DBCursor.getFirstAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? readEvent(row) : null;
     }
     async findByIds(uuids) {
         if (uuids.length === 0)
             return [];
         const placeholders = uuids.map(() => "?").join(",");
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table} WHERE uuid IN (${placeholders}) ORDER BY sequence ASC`, ...uuids);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table} WHERE uuid IN (${placeholders}) ORDER BY sequence ASC`, ...uuids);
+        return rows.map((row) => readEvent(row));
     }
     async findNextPending(internetConnected) {
         let row;
         if (internetConnected) {
-            row = await DBCursor.getFirstAsync(`SELECT uuid, data FROM ${this.table}
+            row = await DBCursor.getFirstAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
          WHERE status = ?
          ORDER BY created_at ASC
          LIMIT 1`, EEventStatus.PENDING);
         }
         else {
-            row = await DBCursor.getFirstAsync(`SELECT uuid, data FROM ${this.table}
+            row = await DBCursor.getFirstAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
          WHERE status = ? AND requires_network = 0
          ORDER BY created_at ASC
          LIMIT 1`, EEventStatus.PENDING);
         }
         if (!row)
             return null;
-        return DomainEvent.fromJSON(row.data);
+        return readEvent(row);
     }
     async findByStatus(status) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE status = ?
        ORDER BY created_at ASC`, status);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByStatuses(statuses) {
         const placeholders = statuses.map(() => "?").join(",");
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE status IN (${placeholders})
        ORDER BY created_at DESC`, ...statuses);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByCorrelationId(correlationId) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE correlation_id = ?
        ORDER BY sequence ASC`, correlationId);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByAggregateId(aggregateId) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE aggregate_id = ?
        ORDER BY created_at ASC`, aggregateId);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByName(name) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE name = ?
        ORDER BY created_at ASC`, name);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findPending() {
         return this.findByStatus(EEventStatus.PENDING);
@@ -124,15 +118,15 @@ class DomainEventRepositoryImpl {
         return result?.count || 0;
     }
     findByIdSync(uuid) {
-        const row = DBCursor.getFirstSync(`SELECT data FROM ${this.table} WHERE uuid = ?`, uuid);
-        return row ? DomainEvent.fromJSON(row.data) : null;
+        const row = DBCursor.getFirstSync(`SELECT ${STORED_COLUMNS} FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? readEvent(row) : null;
     }
     findByIdsSync(uuids) {
         if (uuids.length === 0)
             return [];
         const placeholder = uuids.map(() => "?").join(",");
-        const rows = DBCursor.getAllSync(`SELECT data FROM ${this.table} WHERE uuid IN (${placeholder}) ORDER BY created_at ASC`, ...uuids);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        const rows = DBCursor.getAllSync(`SELECT ${STORED_COLUMNS} FROM ${this.table} WHERE uuid IN (${placeholder}) ORDER BY created_at ASC`, ...uuids);
+        return rows.map((row) => readEvent(row));
     }
     findByRemoteIdSync(remoteId) {
         // DomainEvents don't have remote IDs, return null

package/dist/adapters/repositories/domain_event_dead_letter.repository.d.ts

@@ -1,21 +1,21 @@
-import { DomainEvent } from "../../domain/event_sourcing";
+import { type IntegrationEvent } from "../../domain/events";
 import { ECommonRepository } from "../../domain/repositories";
 import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
 declare class DomainEventDeadLetterRepositoryImpl {
     readonly name = ECommonRepository.DOMAIN_EVENT_DEAD_LETTER;
     readonly table = DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER;
-    save(event: DomainEvent, errorMessage?: string): Promise<void>;
-    findById(uuid: string): Promise<DomainEvent | null>;
-    findAll(): Promise<DomainEvent[]>;
-    findByName(name: string): Promise<DomainEvent[]>;
-    findByCorrelationId(correlationId: string): Promise<DomainEvent[]>;
-    findByAggregateId(aggregateId: string): Promise<DomainEvent[]>;
-    findRecent(limit?: number): Promise<DomainEvent[]>;
+    save(event: IntegrationEvent, errorMessage?: string): Promise<void>;
+    findById(uuid: string): Promise<IntegrationEvent | null>;
+    findAll(): Promise<IntegrationEvent[]>;
+    findByName(name: string): Promise<IntegrationEvent[]>;
+    findByCorrelationId(correlationId: string): Promise<IntegrationEvent[]>;
+    findByAggregateId(aggregateId: string): Promise<IntegrationEvent[]>;
+    findRecent(limit?: number): Promise<IntegrationEvent[]>;
     remove(uuid: string): Promise<void>;
     removeByCorrelationId(correlationId: string): Promise<void>;
     clearAll(): Promise<void>;
-    retry(uuid: string): Promise<DomainEvent | null>;
-    retryByCorrelationId(correlationId: string): Promise<DomainEvent[]>;
+    retry(uuid: string): Promise<IntegrationEvent | null>;
+    retryByCorrelationId(correlationId: string): Promise<IntegrationEvent[]>;
     count(): Promise<number>;
     countByName(name: string): Promise<number>;
 }

package/dist/adapters/repositories/domain_event_dead_letter.repository.js

@@ -1,8 +1,9 @@
-import { DomainEvent } from "../../domain/event_sourcing";
 import { ECommonRepository } from "../../domain/repositories";
 import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
 import { DBCursor } from "../../infrastructure/database";
 import { loggerRepositories } from "../../infrastructure/logger";
+import { readEvent } from "./event_row";
+const STORED_COLUMNS = "data, attempts, error_message, failed_at, source_id, sequence, requires_network, 'FAILED' as status";
 class DomainEventDeadLetterRepositoryImpl {
     name = ECommonRepository.DOMAIN_EVENT_DEAD_LETTER;
     table = DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER;
@@ -13,36 +14,36 @@ class DomainEventDeadLetterRepositoryImpl {
         loggerRepositories.debug(`DomainEvent moved to dead letter: ${event.name} [${event.uuid}]`);
     }
     async findById(uuid) {
-        const row = await DBCursor.getFirstAsync(`SELECT data FROM ${this.table} WHERE uuid = ?`, uuid);
-        return row ? DomainEvent.fromJSON(row.data) : null;
+        const row = await DBCursor.getFirstAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? readEvent(row) : null;
     }
     async findAll() {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table} ORDER BY failed_at DESC`);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table} ORDER BY failed_at DESC`);
+        return rows.map((row) => readEvent(row));
     }
     async findByName(name) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE name = ?
        ORDER BY failed_at DESC`, name);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByCorrelationId(correlationId) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE correlation_id = ?
        ORDER BY sequence ASC`, correlationId);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findByAggregateId(aggregateId) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        WHERE aggregate_id = ?
        ORDER BY failed_at DESC`, aggregateId);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async findRecent(limit = 50) {
-        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+        const rows = await DBCursor.getAllAsync(`SELECT ${STORED_COLUMNS} FROM ${this.table}
        ORDER BY failed_at DESC
        LIMIT ?`, limit);
-        return rows.map((row) => DomainEvent.fromJSON(row.data));
+        return rows.map((row) => readEvent(row));
     }
     async remove(uuid) {
         await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE uuid = ?`, uuid);

package/dist/adapters/repositories/event_row.d.ts

@@ -0,0 +1,13 @@
+import { IntegrationEvent } from "../../domain/events/integration_event";
+export type EventRow = {
+    data: string;
+    status?: string | null;
+    attempts?: number | null;
+    error_message?: string | null;
+    acknowledged_at?: string | null;
+    failed_at?: string | null;
+    source_id?: string | null;
+    sequence?: number | null;
+    requires_network?: number | null;
+};
+export declare function readEvent(row: EventRow): IntegrationEvent;

package/dist/adapters/repositories/event_row.js

@@ -0,0 +1,22 @@
+import { IntegrationEvent } from "../../domain/events/integration_event";
+export function readEvent(row) {
+    const event = IntegrationEvent.fromJSON(row.data);
+    if (row.status)
+        event.status = row.status;
+    if (row.attempts != null)
+        event.attempts = row.attempts;
+    if (row.error_message !== undefined)
+        event.errorMessage = row.error_message;
+    if (row.acknowledged_at !== undefined)
+        event.acknowledgedAt = row.acknowledged_at;
+    if (row.failed_at !== undefined)
+        event.failedAt = row.failed_at;
+    if (row.source_id)
+        event.sourceId = row.source_id;
+    if (row.sequence != null)
+        event.sequence = row.sequence;
+    if (row.requires_network != null) {
+        Object.assign(event, { requiresNetwork: row.requires_network === 1 });
+    }
+    return event;
+}

package/dist/adapters/repositories/sqlite_document_store.d.ts

@@ -0,0 +1,33 @@
+import { type CompiledCriteria } from "../../domain/database/criteria_sql";
+import { type ColumnValue, type DocumentRow, type DocumentStore } from "../../domain/repositories/document_store";
+export declare class SqliteDocumentStore implements DocumentStore {
+    readonly table: string;
+    private readonly columnNames;
+    private readonly integerColumns;
+    private ready;
+    private syncReady;
+    constructor(table: string, columnNames?: readonly string[], integerColumns?: readonly string[]);
+    read(uuid: string): Promise<DocumentRow | null>;
+    readSync(uuid: string): DocumentRow | null;
+    insert(row: DocumentRow): Promise<void>;
+    update(row: DocumentRow, expectedVersion: number): Promise<boolean>;
+    upsert(row: DocumentRow): Promise<void>;
+    remove(uuid: string): Promise<void>;
+    list(): Promise<DocumentRow[]>;
+    selectMatching(compiled: CompiledCriteria): Promise<DocumentRow[]>;
+    hasColumn(name: string): boolean;
+    selectBy(column: string, value: ColumnValue): Promise<DocumentRow[]>;
+    selectBySync(column: string, value: ColumnValue): DocumentRow[];
+    inTransaction(): boolean;
+    transaction<T>(work: () => Promise<T>): Promise<T>;
+    private names;
+    private selected;
+    private values;
+    private definition;
+    private columnDefinition;
+    private ensure;
+    private wanted;
+    private create;
+    private ensureSync;
+    private assertColumn;
+}

package/dist/adapters/repositories/sqlite_document_store.js

@@ -0,0 +1,201 @@
+import { missingColumns, } from "../../domain/database/migration_plan";
+import { DBCursor } from "../../infrastructure/database";
+import { addColumnStatement, tableColumns, tableColumnsSync, } from "../../infrastructure/database/schema";
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export class SqliteDocumentStore {
+    table;
+    columnNames;
+    integerColumns;
+    ready = null;
+    syncReady = false;
+    constructor(table, columnNames = [], integerColumns = []) {
+        this.table = table;
+        this.columnNames = columnNames;
+        assertIdentifier(table);
+        for (const name of columnNames)
+            assertIdentifier(name);
+        this.integerColumns = new Set(integerColumns);
+    }
+    async read(uuid) {
+        await this.ensure();
+        const row = await DBCursor.getFirstAsync(`SELECT ${this.selected()} FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? toDocument(row, this.columnNames) : null;
+    }
+    readSync(uuid) {
+        this.ensureSync();
+        const row = DBCursor.getFirstSync(`SELECT ${this.selected()} FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? toDocument(row, this.columnNames) : null;
+    }
+    async insert(row) {
+        await this.ensure();
+        const names = this.names();
+        await DBCursor.mutateDatabase(`INSERT INTO ${this.table} (${names.join(", ")}) VALUES (${placeholders(names.length)})`, ...this.values(row));
+    }
+    async update(row, expectedVersion) {
+        await this.ensure();
+        const assignments = ["version", "data", ...this.columnNames]
+            .map((name) => `${name} = ?`)
+            .join(", ");
+        const result = await DBCursor.mutateDatabase(`UPDATE ${this.table} SET ${assignments} WHERE uuid = ? AND version = ?`, row.version, row.data, ...this.columnNames.map((name) => row.columns[name] ?? null), row.uuid, expectedVersion);
+        return result.changes === 1;
+    }
+    async upsert(row) {
+        await this.ensure();
+        const names = this.names();
+        const assignments = ["version", "data", ...this.columnNames]
+            .map((name) => `${name} = excluded.${name}`)
+            .join(", ");
+        await DBCursor.mutateDatabase(`INSERT INTO ${this.table} (${names.join(", ")}) VALUES (${placeholders(names.length)}) ON CONFLICT(uuid) DO UPDATE SET ${assignments}`, ...this.values(row));
+    }
+    async remove(uuid) {
+        await this.ensure();
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE uuid = ?`, uuid);
+    }
+    async list() {
+        await this.ensure();
+        const rows = await DBCursor.getAllAsync(`SELECT ${this.selected()} FROM ${this.table}`);
+        return rows.map((row) => toDocument(row, this.columnNames));
+    }
+    async selectMatching(compiled) {
+        await this.ensure();
+        const params = [...compiled.params];
+        let sql = `SELECT ${this.selected()} FROM ${this.table}`;
+        if (compiled.whereSql)
+            sql += ` WHERE ${compiled.whereSql}`;
+        if (compiled.orderSql)
+            sql += ` ORDER BY ${compiled.orderSql}`;
+        if (compiled.limit !== undefined) {
+            sql += " LIMIT ?";
+            params.push(compiled.limit);
+        }
+        else if (compiled.offset > 0) {
+            sql += " LIMIT -1";
+        }
+        if (compiled.offset > 0) {
+            sql += " OFFSET ?";
+            params.push(compiled.offset);
+        }
+        const rows = await DBCursor.getAllAsync(sql, ...params);
+        return rows.map((row) => toDocument(row, this.columnNames));
+    }
+    hasColumn(name) {
+        return this.columnNames.includes(name);
+    }
+    async selectBy(column, value) {
+        this.assertColumn(column);
+        await this.ensure();
+        const rows = await DBCursor.getAllAsync(`SELECT ${this.selected()} FROM ${this.table} WHERE ${column} = ?`, value);
+        return rows.map((row) => toDocument(row, this.columnNames));
+    }
+    selectBySync(column, value) {
+        this.assertColumn(column);
+        this.ensureSync();
+        const rows = DBCursor.getAllSync(`SELECT ${this.selected()} FROM ${this.table} WHERE ${column} = ?`, value);
+        return rows.map((row) => toDocument(row, this.columnNames));
+    }
+    inTransaction() {
+        return DBCursor.inTransaction();
+    }
+    transaction(work) {
+        return DBCursor.transaction(work);
+    }
+    names() {
+        return ["uuid", "version", "data", ...this.columnNames];
+    }
+    selected() {
+        return this.names().join(", ");
+    }
+    values(row) {
+        return [
+            row.uuid,
+            row.version,
+            row.data,
+            ...this.columnNames.map((name) => row.columns[name] ?? null),
+        ];
+    }
+    definition() {
+        const extras = this.columnNames
+            .map((name) => `${name} ${this.columnDefinition(name)}`)
+            .join(", ");
+        const tail = extras ? `, ${extras}` : "";
+        return `CREATE TABLE IF NOT EXISTS ${this.table} (uuid TEXT PRIMARY KEY NOT NULL, version INTEGER NOT NULL, data TEXT NOT NULL${tail})`;
+    }
+    columnDefinition(name) {
+        if (name === "ackedVersion")
+            return "INTEGER NOT NULL DEFAULT 0";
+        return this.integerColumns.has(name) ? "INTEGER" : "TEXT";
+    }
+    ensure() {
+        if (!this.ready) {
+            this.ready = this.create().catch((error) => {
+                this.ready = null;
+                throw error;
+            });
+        }
+        return this.ready;
+    }
+    wanted() {
+        return [
+            { name: "version", definition: "INTEGER NOT NULL DEFAULT 1" },
+            { name: "data", definition: "TEXT NOT NULL DEFAULT '{}'" },
+            ...this.columnNames.map((name) => ({
+                name,
+                definition: this.columnDefinition(name),
+            })),
+        ];
+    }
+    async create() {
+        const existing = await tableColumns(this.table);
+        if (existing.length === 0) {
+            await DBCursor.execAsync(this.definition());
+        }
+        else {
+            for (const column of missingColumns(existing, this.wanted())) {
+                await DBCursor.execAsync(addColumnStatement(this.table, column.name, column.definition));
+            }
+        }
+        for (const name of this.columnNames) {
+            await DBCursor.execAsync(`CREATE INDEX IF NOT EXISTS idx_${this.table}_${name} ON ${this.table} (${name})`);
+        }
+    }
+    ensureSync() {
+        if (this.syncReady)
+            return;
+        const existing = tableColumnsSync(this.table);
+        if (existing.length === 0) {
+            DBCursor.mutateDatabaseSync(this.definition());
+        }
+        else {
+            for (const column of missingColumns(existing, this.wanted())) {
+                DBCursor.mutateDatabaseSync(addColumnStatement(this.table, column.name, column.definition));
+            }
+        }
+        for (const name of this.columnNames) {
+            DBCursor.mutateDatabaseSync(`CREATE INDEX IF NOT EXISTS idx_${this.table}_${name} ON ${this.table} (${name})`);
+        }
+        this.syncReady = true;
+    }
+    assertColumn(name) {
+        if (!this.hasColumn(name))
+            throw new Error(`unknown column: ${name}`);
+    }
+}
+function placeholders(count) {
+    return Array.from({ length: count }, () => "?").join(", ");
+}
+function toDocument(row, columnNames) {
+    const columns = {};
+    for (const name of columnNames)
+        columns[name] = row[name] ?? null;
+    return {
+        uuid: String(row.uuid),
+        version: Number(row.version),
+        data: String(row.data),
+        columns,
+    };
+}
+function assertIdentifier(name) {
+    if (!IDENTIFIER.test(name)) {
+        throw new Error(`invalid SQL identifier: ${name}`);
+    }
+}

package/dist/domain/connectivity/events.d.ts

@@ -1,17 +1,17 @@
-import { DomainEvent } from "../../domain/event_sourcing/domain_event";
+import { DomainEvent } from "../../domain/events/domain_event";
 export declare class InternetIsDownEvent extends DomainEvent {
-    static readonly name = "common.network.v2.internet_is_down";
+    static readonly name = "common.network.down";
     static readonly label = "Internet desconectado";
     static readonly requiresNetwork = false;
-    readonly name = "common.network.v2.internet_is_down";
+    readonly name = "common.network.down";
     readonly label = "Internet desconectado";
     readonly requiresNetwork = false;
 }
 export declare class InternetIsUpEvent extends DomainEvent {
-    static readonly name = "common.network.v2.internet_is_up";
+    static readonly name = "common.network.up";
     static readonly label = "Internet conectado";
     static readonly requiresNetwork = true;
-    readonly name = "common.network.v2.internet_is_up";
+    readonly name = "common.network.up";
     readonly label = "Internet conectado";
     readonly requiresNetwork = true;
 }

package/dist/domain/connectivity/events.js

@@ -1,6 +1,6 @@
-import { DomainEvent } from "../../domain/event_sourcing/domain_event";
+import { DomainEvent } from "../../domain/events/domain_event";
 export class InternetIsDownEvent extends DomainEvent {
-    static name = "common.network.v2.internet_is_down";
+    static name = "common.network.down";
     static label = "Internet desconectado";
     static requiresNetwork = false;
     name = InternetIsDownEvent.name;
@@ -8,7 +8,7 @@ export class InternetIsDownEvent extends DomainEvent {
     requiresNetwork = InternetIsDownEvent.requiresNetwork;
 }
 export class InternetIsUpEvent extends DomainEvent {
-    static name = "common.network.v2.internet_is_up";
+    static name = "common.network.up";
     static label = "Internet conectado";
     static requiresNetwork = true;
     name = InternetIsUpEvent.name;

package/dist/domain/database/criteria.d.ts

@@ -0,0 +1,19 @@
+import { type Criteria, CriteriaBuilder, type Expression } from "@sincpro/criteria";
+/**
+ * What the document store accepts.
+ *
+ * A `Criteria` carries the filter in `selection`. An expression is that filter
+ * alone. A `CriteriaBuilder` is read from `.value`.
+ */
+export type DocumentCriteria<T> = Criteria<T> | CriteriaBuilder<T> | Expression<T>;
+/**
+ * The rows of a document collection that answer a criteria.
+ *
+ * The filter is `selection`. It is evaluated by `@sincpro/criteria`, the same
+ * engine the server uses, over the entities already in memory. `order` sorts
+ * those rows. `pagination` cuts a page only when the criteria asks for one:
+ * a filter with no page returns every match. A grouping is not a list of
+ * documents, so it is refused.
+ */
+export declare function criteriaOf<T>(asked: DocumentCriteria<T>): Criteria<T>;
+export declare function rowsMatching<T>(rows: readonly T[], asked: DocumentCriteria<T>): T[];

package/dist/domain/database/criteria.js

@@ -0,0 +1,36 @@
+import { CriteriaBuilder, InvalidCriteria, } from "@sincpro/criteria";
+import { filtered, paginate, sortRows } from "@sincpro/criteria/engine";
+/**
+ * The rows of a document collection that answer a criteria.
+ *
+ * The filter is `selection`. It is evaluated by `@sincpro/criteria`, the same
+ * engine the server uses, over the entities already in memory. `order` sorts
+ * those rows. `pagination` cuts a page only when the criteria asks for one:
+ * a filter with no page returns every match. A grouping is not a list of
+ * documents, so it is refused.
+ */
+export function criteriaOf(asked) {
+    if (asked instanceof CriteriaBuilder)
+        return asked.value;
+    if (isExpression(asked))
+        return { selection: asked };
+    return asked;
+}
+export function rowsMatching(rows, asked) {
+    const criteria = criteriaOf(asked);
+    if (criteria.grouping !== undefined) {
+        throw new InvalidCriteria("a document collection answers a selection, not a grouping");
+    }
+    const matched = filtered(rows, criteria.selection);
+    const ordered = criteria.order?.length ? sortRows(matched, criteria.order) : [...matched];
+    if (criteria.pagination === undefined)
+        return ordered;
+    return paginate(ordered, criteria, criteria.order ?? []).rows;
+}
+function isExpression(asked) {
+    return ("field" in asked ||
+        "all" in asked ||
+        "any" in asked ||
+        "negate" in asked ||
+        "through" in asked);
+}

package/dist/domain/database/criteria_clock.d.ts

@@ -0,0 +1,8 @@
+import { type Value } from "@sincpro/criteria";
+export interface CriteriaClock {
+    now: Date;
+    timeZone: string;
+}
+export declare function deviceClock(now?: Date): CriteriaClock;
+export declare function readCriteriaValue(value: Value, clock: CriteriaClock, field?: string): Value;
+export declare function periodBounds(value: Value, clock: CriteriaClock): [string, string];