@sincpro/mobile 0.4.4 → 1.0.0

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

@@ -0,0 +1,653 @@
+import { compileCriteria, } from "../../domain/database/criteria_sql";
+import { isChangeTracked } from "../../domain/entity/change_tracking";
+import { assertChecks } from "../../domain/entity/checks";
+import { ERemoteState, RemoteEntity } from "../../domain/entity/entity";
+import { EntityCollection } from "../../domain/entity/entity_collection";
+import { reconcile } from "../../domain/entity/reconcile";
+import { heldEntities, relationPersists, relationRemoves, relations, relationWrites, } from "../../domain/entity/relations";
+import { applyAcknowledgement, takeAcceptedWrite, } from "../../domain/entity/remote_sync";
+import { StoreMode, } from "../../domain/repositories/document_store";
+import { fireHooks, fireSearch, } from "../../domain/repositories/hooks";
+import { DomainAppError, StaleAggregate } from "../../exceptions";
+import { EventBus } from "../../infrastructure/workers";
+import { DomainEventRepository } from "./domain_event.repository";
+import { SqliteDocumentStore } from "./sqlite_document_store";
+const registry = new Map();
+const hookRepos = new Set();
+export class DocumentRepository {
+    type;
+    store;
+    options;
+    inflight = new Map();
+    constructor(type, store, options = {}) {
+        this.type = type;
+        this.store = store;
+        this.options = options;
+        if (registry.has(type)) {
+            throw new DomainAppError(`document repository already registered for ${type.name}`);
+        }
+        registry.set(type, this);
+    }
+    static reset() {
+        registry.clear();
+        hookRepos.clear();
+    }
+    async save(entity, options) {
+        await this.commit(options, async (session) => {
+            for (const item of toItems(entity))
+                await this.persistIn(item, "save", session);
+        });
+    }
+    async upsert(entity) {
+        await this.commit(undefined, async (session) => {
+            for (const item of toItems(entity))
+                await this.persistIn(item, "upsert", session);
+        });
+    }
+    async remove(entity) {
+        const items = Array.isArray(entity) ? entity : [entity];
+        await this.commit({ deliver: false }, async (session) => {
+            for (const item of items)
+                await this.deleteIn(item, session);
+        });
+    }
+    async removeById(uuid) {
+        await this.commit({ deliver: false }, async (session) => {
+            await this.deleteById(session, uuid);
+        });
+    }
+    async publish(events) {
+        this.assertCanWrite();
+        const outbox = this.outbox();
+        await this.store.transaction(async () => {
+            for (const event of events)
+                await outbox.save(event);
+        });
+        outbox.schedule();
+    }
+    kick() {
+        this.options.outbox?.schedule();
+    }
+    async findById(uuid) {
+        return this.loadById(uuid);
+    }
+    findByIdSync(uuid) {
+        return this.loadByIdSync(uuid);
+    }
+    async findByIds(uuids) {
+        const found = [];
+        for (const uuid of uuids) {
+            const one = await this.loadById(uuid);
+            if (one)
+                found.push(one);
+        }
+        await this.afterSearch(found);
+        return new EntityCollection(found);
+    }
+    findByIdsSync(uuids) {
+        const found = [];
+        for (const uuid of uuids) {
+            const one = this.loadByIdSync(uuid);
+            if (one)
+                found.push(one);
+        }
+        return new EntityCollection(found);
+    }
+    async findAll() {
+        const found = await this.readAll();
+        await this.afterSearch(found);
+        return new EntityCollection(found);
+    }
+    async findByCriteria(criteria) {
+        const rows = await this.store.selectMatching(compileCriteria(criteria, this.sqlTarget()));
+        const found = [];
+        for (const row of rows)
+            found.push(await this.hydrate(row));
+        await this.afterSearch(found);
+        return new EntityCollection(found);
+    }
+    async findByRemoteId(remoteId) {
+        const found = await this.findByColumn("remoteId", remoteId);
+        return found[0] ?? null;
+    }
+    findByRemoteIdSync(remoteId) {
+        const select = this.store.selectBySync;
+        if (!select || !this.store.hasColumn("remoteId")) {
+            throw new DomainAppError("this document store cannot query remoteId synchronously");
+        }
+        const row = select.call(this.store, "remoteId", remoteId)[0];
+        return row ? this.hydrateSync(row) : null;
+    }
+    async findByRemoteIds(remoteIds) {
+        const found = [];
+        for (const remoteId of remoteIds)
+            found.push(...(await this.findByColumn("remoteId", remoteId)));
+        await this.afterSearch(found);
+        return new EntityCollection(found);
+    }
+    async findByRemoteState(state) {
+        const states = Array.isArray(state) ? state : [state];
+        const found = [];
+        for (const one of states)
+            found.push(...(await this.findByColumn("remoteState", one)));
+        await this.afterSearch(found);
+        return new EntityCollection(found);
+    }
+    async findDirty() {
+        if (!this.store.hasColumn("ackedVersion")) {
+            const found = (await this.readAll()).filter((entity) => entity instanceof RemoteEntity && entity.isDirty);
+            await this.afterSearch(found);
+            return new EntityCollection(found);
+        }
+        return this.findByCriteria({
+            selection: {
+                field: "version",
+                operator: "!=",
+                value: { $: "field", name: "ackedVersion" },
+            },
+        });
+    }
+    async acknowledge(entity, remoteId) {
+        if (!(entity instanceof RemoteEntity)) {
+            throw new DomainAppError("only a remote document can be acknowledged");
+        }
+        if (entity.version === 0) {
+            throw new DomainAppError("acknowledge a document after it has been saved");
+        }
+        const existing = await this.store.read(entity.uuid);
+        if (!existing || storedVersion(existing) !== entity.version) {
+            throw new StaleAggregate(`${entity.constructor.name} ${entity.uuid} is at version ${existing ? storedVersion(existing) : "none"}, not ${entity.version}`);
+        }
+        applyAcknowledgement(entity, remoteId);
+        const row = {
+            uuid: entity.uuid,
+            version: entity.version,
+            data: documentData(entity),
+            columns: this.columnValues(entity),
+        };
+        const written = await this.store.update(row, entity.version);
+        if (!written) {
+            throw new StaleAggregate(`${entity.constructor.name} ${entity.uuid} changed while it was acknowledged`);
+        }
+        if (isChangeTracked(entity))
+            entity.takeSnapshot();
+    }
+    async pull(local, incoming) {
+        if (!(incoming instanceof RemoteEntity) || (local && !(local instanceof RemoteEntity))) {
+            throw new DomainAppError("only a remote document can be pulled");
+        }
+        const decision = reconcile(local, incoming);
+        if (decision.write !== "keep")
+            await this.save(decision.entity);
+        return decision.entity;
+    }
+    async commit(options, work) {
+        this.assertCanWrite();
+        let session = null;
+        try {
+            await this.store.transaction(async () => {
+                session = this.openSession(options);
+                await work(session);
+            });
+            this.schedule(session);
+        }
+        catch (error) {
+            if (session)
+                restoreSession(session);
+            throw error;
+        }
+    }
+    assertCanWrite() {
+        const self = this;
+        if (hookRepos.has(self) || (hookRepos.size > 0 && this.store.inTransaction())) {
+            throw new DomainAppError("a hook cannot write through the same repository");
+        }
+    }
+    async persistIn(entity, kind, session) {
+        if (session.saving.has(entity.uuid))
+            return;
+        session.saving.add(entity.uuid);
+        remember(session, entity);
+        const hooks = this.hooksOf(entity);
+        const creating = entity.isNew;
+        if (kind === "save") {
+            await this.runHooks(hooks, "before_save", entity);
+            await this.runHooks(hooks, creating ? "before_create" : "before_update", entity);
+            assertChecks(entity);
+            await this.cascade(entity, kind, session);
+            if (isChangeTracked(entity))
+                entity.recordChanges();
+        }
+        else {
+            await this.runHooks(hooks, "before_save", entity);
+            await this.cascade(entity, kind, session);
+        }
+        await this.writeRow(entity, kind === "upsert");
+        await this.flush(entity, session);
+        entity.noteHeld();
+        if (isChangeTracked(entity))
+            entity.takeSnapshot();
+        if (kind === "save") {
+            await this.runHooks(hooks, creating ? "after_create" : "after_update", entity);
+        }
+        await this.runHooks(hooks, "after_save", entity);
+    }
+    async cascade(entity, kind, session) {
+        for (const relation of relations(entity)) {
+            const current = heldEntities(fieldOf(entity, relation.field));
+            const writes = relationWrites(relation);
+            const removes = relationRemoves(relation);
+            if (!writes && !removes)
+                continue;
+            const repo = this.repositoryFor(relation.type);
+            if (removes) {
+                const seen = new Set(current.map((child) => child.uuid));
+                for (const previous of entity.heldIds(relation.field)) {
+                    if (!seen.has(previous))
+                        await repo.deleteById(session, previous);
+                }
+            }
+            if (!writes)
+                continue;
+            for (const child of current) {
+                if (relationPersists(relation, child.isNew)) {
+                    await repo.persistIn(child, kind, session);
+                }
+            }
+        }
+    }
+    async deleteIn(entity, session) {
+        if (session.saving.has(entity.uuid))
+            return;
+        session.saving.add(entity.uuid);
+        remember(session, entity);
+        const hooks = this.hooksOf(entity);
+        await this.runHooks(hooks, "before_remove", entity);
+        for (const relation of relations(entity)) {
+            if (!relationRemoves(relation))
+                continue;
+            const repo = this.repositoryFor(relation.type);
+            for (const child of heldEntities(fieldOf(entity, relation.field))) {
+                await repo.deleteIn(child, session);
+            }
+        }
+        await this.store.remove(entity.uuid);
+        await this.runHooks(hooks, "after_remove", entity);
+    }
+    async deleteById(session, uuid) {
+        const found = await this.loadById(uuid);
+        if (found)
+            await this.deleteIn(found, session);
+    }
+    async writeRow(entity, upsert) {
+        const existing = await this.store.read(entity.uuid);
+        const previous = existing ? storedVersion(existing) : null;
+        const expected = previous === null ? 0 : previous;
+        if (!upsert && expected !== entity.version) {
+            throw new StaleAggregate(`${entity.constructor.name} ${entity.uuid} is at version ${previous ?? "none"}, not ${entity.version}`);
+        }
+        entity.version = (previous ?? 0) + 1;
+        if (entity instanceof RemoteEntity) {
+            if (takeAcceptedWrite(entity))
+                entity.ackedVersion = entity.version;
+            entity.remoteState = entity.isDirty ? ERemoteState.PENDING : ERemoteState.SYNCED;
+        }
+        entity.updatedAt = new Date().toISOString();
+        if (!entity.createdAt)
+            entity.createdAt = entity.updatedAt;
+        const row = {
+            uuid: entity.uuid,
+            version: entity.version,
+            data: documentData(entity),
+            columns: this.columnValues(entity),
+        };
+        if (upsert) {
+            await this.store.upsert(row);
+            return;
+        }
+        if (previous === null) {
+            try {
+                await this.store.insert(row);
+            }
+            catch (error) {
+                const raced = await this.store.read(entity.uuid);
+                if (raced) {
+                    throw new StaleAggregate(`${entity.constructor.name} ${entity.uuid} is at version ${storedVersion(raced)}, not 0`);
+                }
+                throw error;
+            }
+            return;
+        }
+        const written = await this.store.update(row, expected);
+        if (!written) {
+            const raced = await this.store.read(entity.uuid);
+            const current = raced ? storedVersion(raced) : "none";
+            throw new StaleAggregate(`${entity.constructor.name} ${entity.uuid} is at version ${current}, not ${expected}`);
+        }
+    }
+    columnValues(entity) {
+        const columns = { ...(this.options.columns?.(entity) ?? {}) };
+        if (!(entity instanceof RemoteEntity))
+            return columns;
+        if (this.store.hasColumn("remoteId") && columns.remoteId === undefined) {
+            columns.remoteId = entity.remoteId ?? null;
+        }
+        if (this.store.hasColumn("remoteState") && columns.remoteState === undefined) {
+            columns.remoteState = entity.remoteState;
+        }
+        if (this.store.hasColumn("ackedVersion") && columns.ackedVersion === undefined) {
+            columns.ackedVersion = entity.ackedVersion;
+        }
+        return columns;
+    }
+    async flush(entity, session) {
+        const events = entity.releaseDeliverable();
+        if (events.length === 0)
+            return;
+        const outbox = this.options.outbox;
+        if (!outbox) {
+            if ((this.options.mode ?? StoreMode.LOCAL) === StoreMode.RELAY) {
+                throw new DomainAppError("a relay repository needs an outbox");
+            }
+            entity.restoreRecorded(events);
+            return;
+        }
+        for (const event of events)
+            await outbox.save(event);
+        if (session.deliver)
+            session.outboxes.add(outbox);
+    }
+    async loadById(uuid) {
+        const pending = this.inflight.get(uuid);
+        if (pending)
+            return pending;
+        const row = await this.store.read(uuid);
+        return row ? this.hydrate(row) : null;
+    }
+    loadByIdSync(uuid) {
+        const pending = this.inflight.get(uuid);
+        if (pending)
+            return pending;
+        const readSync = this.store.readSync;
+        if (!readSync) {
+            throw new DomainAppError("this document store cannot read synchronously");
+        }
+        const row = readSync.call(this.store, uuid);
+        return row ? this.hydrateSync(row) : null;
+    }
+    async hydrate(row) {
+        const pending = this.inflight.get(row.uuid);
+        if (pending)
+            return pending;
+        const entity = this.materialize(row);
+        this.inflight.set(entity.uuid, entity);
+        try {
+            await this.attachRelations(entity);
+            entity.noteHeld();
+            await this.runHooks(this.hooksOf(entity), "after_read", entity);
+            if (isChangeTracked(entity))
+                entity.takeSnapshot();
+            return entity;
+        }
+        finally {
+            this.inflight.delete(entity.uuid);
+        }
+    }
+    hydrateSync(row) {
+        const pending = this.inflight.get(row.uuid);
+        if (pending)
+            return pending;
+        const entity = this.materialize(row);
+        this.inflight.set(entity.uuid, entity);
+        try {
+            this.attachRelationsSync(entity);
+            entity.noteHeld();
+            if (isChangeTracked(entity))
+                entity.takeSnapshot();
+            return entity;
+        }
+        finally {
+            this.inflight.delete(entity.uuid);
+        }
+    }
+    materialize(row) {
+        const parsed = JSON.parse(row.data);
+        const entity = this.type.fromJSON(parsed);
+        if (typeof row.version === "number" && !Number.isNaN(row.version)) {
+            entity.version = row.version;
+        }
+        else if (typeof parsed.version !== "number") {
+            entity.version = 1;
+        }
+        if (entity instanceof RemoteEntity) {
+            const storedAck = row.columns.ackedVersion;
+            if (typeof storedAck === "number" && !Number.isNaN(storedAck)) {
+                entity.ackedVersion = storedAck;
+            }
+            else if (entity.ackedVersion === 0 &&
+                entity.remoteState === ERemoteState.SYNCED &&
+                entity.version > 0) {
+                entity.ackedVersion = entity.version;
+            }
+        }
+        return entity;
+    }
+    async attachRelations(entity) {
+        const record = entity;
+        for (const relation of relations(entity)) {
+            record[relation.field] = await this.resolveRelation(relation, record[relation.field]);
+        }
+    }
+    attachRelationsSync(entity) {
+        const record = entity;
+        for (const relation of relations(entity)) {
+            record[relation.field] = this.resolveRelationSync(relation, record[relation.field]);
+        }
+    }
+    async resolveRelation(relation, value) {
+        if (Array.isArray(value)) {
+            const resolved = [];
+            for (const item of value) {
+                const one = await this.resolveOne(relation, item);
+                if (one != null)
+                    resolved.push(one);
+            }
+            return resolved;
+        }
+        return this.resolveOne(relation, value);
+    }
+    resolveRelationSync(relation, value) {
+        if (Array.isArray(value)) {
+            const resolved = [];
+            for (const item of value) {
+                const one = this.resolveOneSync(relation, item);
+                if (one != null)
+                    resolved.push(one);
+            }
+            return resolved;
+        }
+        return this.resolveOneSync(relation, value);
+    }
+    async resolveOne(relation, value) {
+        if (typeof value === "string") {
+            return this.repositoryFor(relation.type).loadById(value);
+        }
+        if (value && typeof value === "object")
+            return entityFromJSON(relation, value);
+        return value ?? null;
+    }
+    resolveOneSync(relation, value) {
+        if (typeof value === "string") {
+            return this.repositoryFor(relation.type).loadByIdSync(value);
+        }
+        if (value && typeof value === "object")
+            return entityFromJSON(relation, value);
+        return value ?? null;
+    }
+    async findByColumn(column, value) {
+        if (this.store.hasColumn(column)) {
+            const rows = await this.store.selectBy(column, value);
+            const found = [];
+            for (const row of rows)
+                found.push(await this.hydrate(row));
+            return found;
+        }
+        const found = [];
+        for (const item of await this.readAll()) {
+            if (item[column] === value)
+                found.push(item);
+        }
+        return found;
+    }
+    async readAll() {
+        const rows = await this.store.list();
+        const found = [];
+        for (const row of rows)
+            found.push(await this.hydrate(row));
+        return found;
+    }
+    async afterSearch(records) {
+        await fireSearch(this.options.hooks?.ofType(this.type) ?? [], records);
+    }
+    async runHooks(hooks, moment, entity) {
+        if (hooks.length === 0)
+            return;
+        const self = this;
+        hookRepos.add(self);
+        try {
+            await fireHooks(hooks, moment, entity);
+        }
+        finally {
+            hookRepos.delete(self);
+        }
+    }
+    hooksOf(entity) {
+        return this.options.hooks?.of(entity) ?? [];
+    }
+    sqlTarget() {
+        return {
+            table: this.store.table,
+            column: (field) => field === "uuid" || field === "version" || this.store.hasColumn(field),
+            relation: (name) => {
+                const declared = relations(Object.create(this.type.prototype)).find((item) => item.field === name);
+                if (!declared)
+                    return undefined;
+                return this.repositoryFor(declared.type).sqlTarget();
+            },
+        };
+    }
+    repositoryFor(type) {
+        const found = registry.get(type);
+        if (!found)
+            throw new DomainAppError(`no document repository for ${type.name}`);
+        return found;
+    }
+    openSession(options) {
+        const mode = this.options.mode ?? StoreMode.LOCAL;
+        return {
+            deliver: options?.deliver ?? mode === StoreMode.RELAY,
+            outboxes: new Set(),
+            saving: new Set(),
+            remembered: new Map(),
+        };
+    }
+    schedule(session) {
+        if (!session?.deliver)
+            return;
+        for (const outbox of session.outboxes)
+            outbox.schedule();
+    }
+    outbox() {
+        if (!this.options.outbox)
+            throw new DomainAppError("publish needs an outbox");
+        return this.options.outbox;
+    }
+}
+function remember(session, entity) {
+    if (session.remembered.has(entity.uuid))
+        return;
+    session.remembered.set(entity.uuid, {
+        entity,
+        version: entity.version,
+        updatedAt: entity.updatedAt,
+        createdAt: entity.createdAt,
+        events: [...entity.recordedEvents()],
+        eventIds: [...entity.eventIds],
+    });
+}
+function restoreSession(active) {
+    for (const remembered of active.remembered.values()) {
+        remembered.entity.version = remembered.version;
+        remembered.entity.updatedAt = remembered.updatedAt;
+        remembered.entity.createdAt = remembered.createdAt;
+        remembered.entity.eventIds = [...remembered.eventIds];
+        remembered.entity.replaceRecorded(remembered.events);
+    }
+}
+function storedVersion(row) {
+    if (typeof row.version === "number" && !Number.isNaN(row.version))
+        return row.version;
+    const parsed = JSON.parse(row.data);
+    return typeof parsed.version === "number" ? parsed.version : 1;
+}
+function documentData(entity) {
+    const parsed = JSON.parse(entity.asJSON());
+    const record = entity;
+    for (const relation of relations(entity)) {
+        const value = record[relation.field];
+        if (Array.isArray(value)) {
+            parsed[relation.field] = heldEntities(value).map((child) => child.uuid);
+            continue;
+        }
+        const held = heldEntities(value);
+        if (held.length === 1)
+            parsed[relation.field] = held[0].uuid;
+    }
+    return JSON.stringify(parsed);
+}
+function fieldOf(entity, field) {
+    return entity[field];
+}
+function entityFromJSON(relation, value) {
+    const type = relation.type;
+    return type.fromJSON(value);
+}
+function toItems(entity) {
+    if (Array.isArray(entity))
+        return entity;
+    if (entity instanceof EntityCollection)
+        return entity.toArray();
+    return [entity];
+}
+function extendsRemote(type) {
+    return type === RemoteEntity || type.prototype instanceof RemoteEntity;
+}
+export function sqliteDocuments(type, table, spec = {}) {
+    const columns = { ...(spec.columns ?? {}) };
+    if (extendsRemote(type)) {
+        columns.remoteId ??= (entity) => entity.remoteId ?? null;
+        columns.remoteState ??= (entity) => entity.remoteState ?? null;
+        columns.ackedVersion ??= (entity) => entity.ackedVersion ?? 0;
+    }
+    const names = Object.keys(columns);
+    const integers = names.filter((name) => name === "remoteId" || name === "ackedVersion");
+    const readColumns = (entity) => {
+        const row = {};
+        for (const name of names)
+            row[name] = columns[name](entity);
+        return row;
+    };
+    const mode = spec.mode ?? StoreMode.LOCAL;
+    return new DocumentRepository(type, new SqliteDocumentStore(table, names, integers), {
+        mode,
+        hooks: spec.hooks,
+        outbox: spec.outbox ?? (mode === StoreMode.RELAY ? sqliteOutbox() : undefined),
+        columns: names.length > 0 ? readColumns : undefined,
+    });
+}
+function sqliteOutbox() {
+    return {
+        save: (event) => DomainEventRepository.save(event),
+        schedule: () => EventBus.schedule(),
+    };
+}

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

@@ -1,32 +1,32 @@
-import { DomainEvent, EEventStatus } from "../../domain/event_sourcing";
+import { EEventStatus, type IntegrationEvent } from "../../domain/events";
 import { ECommonRepository } from "../../domain/repositories";
 import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
 declare class DomainEventRepositoryImpl {
     readonly name = ECommonRepository.DOMAIN_EVENT;
     readonly table = DATABASE_TABLES.DOMAIN_EVENTS;
     private hasPendingDuplicate;
-    save(event: DomainEvent): Promise<void>;
-    saveMany(events: DomainEvent[]): Promise<void>;
-    findById(uuid: string): Promise<DomainEvent | null>;
-    findByIds(uuids: string[]): Promise<DomainEvent[]>;
-    findNextPending(internetConnected: boolean): Promise<DomainEvent | null>;
-    findByStatus(status: EEventStatus): Promise<DomainEvent[]>;
-    findByStatuses(statuses: EEventStatus[]): Promise<DomainEvent[]>;
-    findByCorrelationId(correlationId: string): Promise<DomainEvent[]>;
-    findByAggregateId(aggregateId: string): Promise<DomainEvent[]>;
-    findByName(name: string): Promise<DomainEvent[]>;
-    findPending(): Promise<DomainEvent[]>;
-    findFailed(): Promise<DomainEvent[]>;
+    save(event: IntegrationEvent): Promise<void>;
+    saveMany(events: IntegrationEvent[]): Promise<void>;
+    findById(uuid: string): Promise<IntegrationEvent | null>;
+    findByIds(uuids: string[]): Promise<IntegrationEvent[]>;
+    findNextPending(internetConnected: boolean): Promise<IntegrationEvent | null>;
+    findByStatus(status: EEventStatus): Promise<IntegrationEvent[]>;
+    findByStatuses(statuses: EEventStatus[]): Promise<IntegrationEvent[]>;
+    findByCorrelationId(correlationId: string): Promise<IntegrationEvent[]>;
+    findByAggregateId(aggregateId: string): Promise<IntegrationEvent[]>;
+    findByName(name: string): Promise<IntegrationEvent[]>;
+    findPending(): Promise<IntegrationEvent[]>;
+    findFailed(): Promise<IntegrationEvent[]>;
     remove(uuid: string): Promise<void>;
     removeByCorrelationId(correlationId: string): Promise<void>;
     removeAcknowledged(): Promise<void>;
     clearAll(): Promise<void>;
     count(): Promise<number>;
     countByStatus(status: EEventStatus): Promise<number>;
-    findByIdSync(uuid: string): DomainEvent | null;
-    findByIdsSync(uuids: string[]): DomainEvent[];
-    findByRemoteIdSync(remoteId: number | string): DomainEvent | null;
-    findByRemoteIdsSync(remoteIds: (number | string)[]): DomainEvent[];
+    findByIdSync(uuid: string): IntegrationEvent | null;
+    findByIdsSync(uuids: string[]): IntegrationEvent[];
+    findByRemoteIdSync(remoteId: number | string): IntegrationEvent | null;
+    findByRemoteIdsSync(remoteIds: (number | string)[]): IntegrationEvent[];
 }
 export declare const DomainEventRepository: DomainEventRepositoryImpl;
 export {};