@sincpro/mobile 0.1.0

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

@@ -0,0 +1,147 @@
+import { DomainEvent, EEventStatus } from "../../domain/event_sourcing";
+import { ECommonRepository } from "../../domain/repositories";
+import { DBCursor } from "../../infrastructure/database";
+import { loggerRepositories } from "../../infrastructure/logger";
+class DomainEventRepositoryImpl {
+    name = ECommonRepository.DOMAIN_EVENT;
+    table = "domain_events" /* 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);
+        return existing !== null;
+    }
+    async save(event) {
+        if (event.isPending) {
+            const isDuplicate = await this.hasPendingDuplicate(event);
+            if (isDuplicate) {
+                loggerRepositories.warn(`DomainEvent duplicated, skipping: ${event.name}`);
+                return;
+            }
+        }
+        await DBCursor.mutateDatabase(`INSERT OR REPLACE INTO ${this.table} 
+       (uuid, name, label, data, requires_network, created_at, status, attempts, error_message, acknowledged_at, failed_at, aggregate_id, source_id, correlation_id, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, event.uuid, event.name, event.label, event.asJSON(), event.requiresNetwork ? 1 : 0, event.createdAt, event.status, event.attempts, event.errorMessage, event.acknowledgedAt, event.failedAt, event.aggregateId, event.sourceId, event.correlationId, event.sequence);
+        loggerRepositories.debug(`DomainEvent saved: ${event.name} [${event.uuid}]`);
+    }
+    async saveMany(events) {
+        for (const event of events) {
+            await this.save(event);
+        }
+    }
+    async findById(uuid) {
+        const row = await DBCursor.getFirstAsync(`SELECT data FROM ${this.table} WHERE uuid = ?`, uuid);
+        return row ? DomainEvent.fromJSON(row.data) : 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));
+    }
+    async findNextPending(internetConnected) {
+        let row;
+        if (internetConnected) {
+            row = await DBCursor.getFirstAsync(`SELECT uuid, data 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}
+         WHERE status = ? AND requires_network = 0
+         ORDER BY created_at ASC
+         LIMIT 1`, EEventStatus.PENDING);
+        }
+        if (!row)
+            return null;
+        return DomainEvent.fromJSON(row.data);
+    }
+    async findByStatus(status) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE status = ?
+       ORDER BY created_at ASC`, status);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByStatuses(statuses) {
+        const placeholders = statuses.map(() => "?").join(",");
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE status IN (${placeholders})
+       ORDER BY created_at DESC`, ...statuses);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByCorrelationId(correlationId) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE correlation_id = ?
+       ORDER BY sequence ASC`, correlationId);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByAggregateId(aggregateId) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE aggregate_id = ?
+       ORDER BY created_at ASC`, aggregateId);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByName(name) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE name = ?
+       ORDER BY created_at ASC`, name);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findPending() {
+        return this.findByStatus(EEventStatus.PENDING);
+    }
+    async findFailed() {
+        return this.findByStatus(EEventStatus.FAILED);
+    }
+    async remove(uuid) {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE uuid = ?`, uuid);
+    }
+    async removeByCorrelationId(correlationId) {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE correlation_id = ?`, correlationId);
+    }
+    async removeAcknowledged() {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE status = ?`, EEventStatus.ACKNOWLEDGED);
+    }
+    async clearAll() {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table}`);
+        loggerRepositories.info("DomainEvent table cleared");
+    }
+    async count() {
+        const result = await DBCursor.getFirstAsync(`SELECT COUNT(*) as count FROM ${this.table}`);
+        return result?.count || 0;
+    }
+    async countByStatus(status) {
+        const result = await DBCursor.getFirstAsync(`SELECT COUNT(*) as count FROM ${this.table} WHERE status = ?`, status);
+        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;
+    }
+    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));
+    }
+    findByRemoteIdSync(remoteId) {
+        // DomainEvents don't have remote IDs, return null
+        loggerRepositories.warn(`findByRemoteIdSync called on DomainEventRepository: ${remoteId} - DomainEvents don't have remote IDs`);
+        return null;
+    }
+    findByRemoteIdsSync(remoteIds) {
+        // DomainEvents don't have remote IDs, return empty array
+        loggerRepositories.warn(`findByRemoteIdsSync called on DomainEventRepository with ${remoteIds.length} ids - DomainEvents don't have remote IDs`);
+        return [];
+    }
+}
+export const DomainEventRepository = new DomainEventRepositoryImpl();

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

@@ -0,0 +1,23 @@
+import { DomainEvent } from "../../domain/event_sourcing";
+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[]>;
+    remove(uuid: string): Promise<void>;
+    removeByCorrelationId(correlationId: string): Promise<void>;
+    clearAll(): Promise<void>;
+    retry(uuid: string): Promise<DomainEvent | null>;
+    retryByCorrelationId(correlationId: string): Promise<DomainEvent[]>;
+    count(): Promise<number>;
+    countByName(name: string): Promise<number>;
+}
+export declare const DomainEventDeadLetterRepository: DomainEventDeadLetterRepositoryImpl;
+export {};

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

@@ -0,0 +1,81 @@
+import { DomainEvent } from "../../domain/event_sourcing";
+import { ECommonRepository } from "../../domain/repositories";
+import { DBCursor } from "../../infrastructure/database";
+import { loggerRepositories } from "../../infrastructure/logger";
+class DomainEventDeadLetterRepositoryImpl {
+    name = ECommonRepository.DOMAIN_EVENT_DEAD_LETTER;
+    table = "domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */;
+    async save(event, errorMessage) {
+        await DBCursor.mutateDatabase(`INSERT INTO ${this.table} 
+       (uuid, name, label, data, requires_network, created_at, attempts, error_message, failed_at, aggregate_id, source_id, correlation_id, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, event.uuid, event.name, event.label, event.asJSON(), event.requiresNetwork ? 1 : 0, event.createdAt, event.attempts, errorMessage || event.errorMessage, new Date().toISOString(), event.aggregateId, event.sourceId, event.correlationId, event.sequence);
+        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;
+    }
+    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));
+    }
+    async findByName(name) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE name = ?
+       ORDER BY failed_at DESC`, name);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByCorrelationId(correlationId) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE correlation_id = ?
+       ORDER BY sequence ASC`, correlationId);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findByAggregateId(aggregateId) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       WHERE aggregate_id = ?
+       ORDER BY failed_at DESC`, aggregateId);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async findRecent(limit = 50) {
+        const rows = await DBCursor.getAllAsync(`SELECT data FROM ${this.table}
+       ORDER BY failed_at DESC
+       LIMIT ?`, limit);
+        return rows.map((row) => DomainEvent.fromJSON(row.data));
+    }
+    async remove(uuid) {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE uuid = ?`, uuid);
+        loggerRepositories.debug(`Dead letter removed: ${uuid}`);
+    }
+    async removeByCorrelationId(correlationId) {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table} WHERE correlation_id = ?`, correlationId);
+    }
+    async clearAll() {
+        await DBCursor.mutateDatabase(`DELETE FROM ${this.table}`);
+        loggerRepositories.info("Dead letter table cleared");
+    }
+    async retry(uuid) {
+        const event = await this.findById(uuid);
+        if (!event)
+            return null;
+        await this.remove(uuid);
+        event.retry();
+        return event;
+    }
+    async retryByCorrelationId(correlationId) {
+        const events = await this.findByCorrelationId(correlationId);
+        if (events.length === 0)
+            return [];
+        await this.removeByCorrelationId(correlationId);
+        return events.map((event) => event.retry());
+    }
+    async count() {
+        const result = await DBCursor.getFirstAsync(`SELECT COUNT(*) as count FROM ${this.table}`);
+        return result?.count || 0;
+    }
+    async countByName(name) {
+        const result = await DBCursor.getFirstAsync(`SELECT COUNT(*) as count FROM ${this.table} WHERE name = ?`, name);
+        return result?.count || 0;
+    }
+}
+export const DomainEventDeadLetterRepository = new DomainEventDeadLetterRepositoryImpl();

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

@@ -0,0 +1,10 @@
+import { ECommonRepository } from "../../domain/repositories";
+import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
+declare class SettingsRepositoryImpl {
+    readonly name = ECommonRepository.SETTINGS;
+    readonly table = DATABASE_TABLES.SETTINGS;
+    saveOneSetting(name: string, value: any): Promise<void>;
+    getSettingByName(name: string): Promise<any | null>;
+}
+export declare const SettingsRepository: SettingsRepositoryImpl;
+export {};

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

@@ -0,0 +1,21 @@
+import { ECommonRepository } from "../../domain/repositories";
+import { DBCursor } from "../../infrastructure/database";
+class SettingsRepositoryImpl {
+    name = ECommonRepository.SETTINGS;
+    table = "settings" /* DATABASE_TABLES.SETTINGS */;
+    async saveOneSetting(name, value) {
+        const type = typeof value;
+        await DBCursor.mutateDatabase(`INSERT OR REPLACE INTO ${"settings" /* DATABASE_TABLES.SETTINGS */} (name, value, type)
+       VALUES (?, ?, ?)`, name, JSON.stringify(value), type);
+    }
+    async getSettingByName(name) {
+        const row = await DBCursor.getFirstAsync(`SELECT value, type
+       FROM ${"settings" /* DATABASE_TABLES.SETTINGS */}
+       WHERE name = ?`, name);
+        if (!row) {
+            return null;
+        }
+        return JSON.parse(row.value);
+    }
+}
+export const SettingsRepository = new SettingsRepositoryImpl();

package/dist/adapters/webview.adapter.d.ts

@@ -0,0 +1,10 @@
+import { type IInjectedScript } from "../domain/webview";
+declare class WebViewAdapterImpl {
+    readonly printInterceptor: IInjectedScript;
+    readonly contentHeightReporter: IInjectedScript;
+    readonly ajaxInterceptor: IInjectedScript;
+    getDefaultInterceptors(): IInjectedScript[];
+    getAllInterceptors(): IInjectedScript[];
+}
+export declare const WebViewAdapter: WebViewAdapterImpl;
+export {};

package/dist/adapters/webview.adapter.js

@@ -0,0 +1,166 @@
+import { EWebViewMessageType } from "../domain/webview";
+const HTML2CANVAS_CDN = "https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js";
+const CANVAS_SCALE = 2.0;
+function createPrintInterceptor() {
+    return {
+        name: "print_interceptor",
+        script: `
+    (function() {
+      if (window.__printInterceptorLoaded) return;
+      window.__printInterceptorLoaded = true;
+
+      try {
+        window.ReactNativeWebView.postMessage(JSON.stringify({
+          type: 'DEBUG_PRINT',
+          debug: { message: 'Script started', ts: Date.now() }
+        }));
+      } catch(e) {}
+
+      var CANVAS_SCALE = ${CANVAS_SCALE};
+
+      function loadHtml2Canvas() {
+        return new Promise(function(resolve, reject) {
+          if (window.html2canvas) {
+            resolve(window.html2canvas);
+            return;
+          }
+          var script = document.createElement('script');
+          script.src = '${HTML2CANVAS_CDN}';
+          script.onload = function() { resolve(window.html2canvas); };
+          script.onerror = function() { reject(new Error('Failed to load html2canvas')); };
+          document.head.appendChild(script);
+        });
+      }
+
+      function captureElement(element) {
+        return loadHtml2Canvas().then(function(html2canvas) {
+          return html2canvas(element, {
+            backgroundColor: '#ffffff',
+            scale: CANVAS_SCALE,
+            useCORS: true,
+            allowTaint: true,
+            logging: false
+          });
+        });
+      }
+
+      function findPrintableElement() {
+        var selectors = ['.sp-printable-roll', '.pos-receipt', '.o_report_layout_standard', '.page', '.sheet'];
+        for (var i = 0; i < selectors.length; i++) {
+          var el = document.querySelector(selectors[i]);
+          if (el) return el;
+        }
+        return document.body;
+      }
+
+      var originalPrint = window.print;
+      window.print = function() {
+        try {
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: 'DEBUG_PRINT',
+            debug: { message: 'print() called', ts: Date.now() }
+          }));
+        } catch(e) {}
+        
+        var element = findPrintableElement();
+        
+        try {
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: 'DEBUG_PRINT',
+            debug: { 
+              message: 'Element: ' + element.tagName + '.' + (element.className || 'no-class'),
+              w: element.offsetWidth,
+              h: element.offsetHeight
+            }
+          }));
+        } catch(e) {}
+        
+        captureElement(element).then(function(canvas) {
+          var base64 = canvas.toDataURL('image/png').replace('data:image/png;base64,', '');
+          
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: '${EWebViewMessageType.PRINT_IMAGE}',
+            image: base64,
+            width: canvas.width,
+            height: canvas.height,
+            metadata: {
+              url: window.location.href,
+              title: document.title,
+              capturedAt: new Date().toISOString()
+            }
+          }));
+        }).catch(function(error) {
+          try {
+            window.ReactNativeWebView.postMessage(JSON.stringify({
+              type: 'DEBUG_PRINT',
+              debug: { message: 'ERROR: ' + error.message }
+            }));
+          } catch(e) {}
+          originalPrint.call(window);
+        });
+      };
+
+      try {
+        window.ReactNativeWebView.postMessage(JSON.stringify({
+          type: '${EWebViewMessageType.INJECTION_READY}',
+          injector: 'PrintInterceptor'
+        }));
+      } catch(e) {}
+
+      true;
+    })();
+  `,
+    };
+}
+function createContentHeightReporter() {
+    return {
+        name: "content_height_reporter",
+        script: `
+    (function() {
+      function reportHeight() {
+        var height = document.body.scrollHeight || document.documentElement.scrollHeight;
+        window.ReactNativeWebView.postMessage(JSON.stringify({
+          type: '${EWebViewMessageType.CONTENT_READY}',
+          height: height
+        }));
+      }
+
+      setTimeout(reportHeight, 200);
+      true;
+    })();
+  `,
+    };
+}
+function createAjaxInterceptor() {
+    return {
+        name: "ajax_interceptor",
+        script: `
+    (function() {
+      var originalFetch = window.fetch;
+      window.fetch = function(url, options) {
+        return originalFetch.apply(this, arguments).then(function(response) {
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: '${EWebViewMessageType.AJAX_INTERCEPTED}',
+            url: typeof url === 'string' ? url : url.url,
+            method: options?.method || 'GET'
+          }));
+          return response;
+        });
+      };
+      true;
+    })();
+  `,
+    };
+}
+class WebViewAdapterImpl {
+    printInterceptor = createPrintInterceptor();
+    contentHeightReporter = createContentHeightReporter();
+    ajaxInterceptor = createAjaxInterceptor();
+    getDefaultInterceptors() {
+        return [this.printInterceptor];
+    }
+    getAllInterceptors() {
+        return [this.printInterceptor, this.ajaxInterceptor];
+    }
+}
+export const WebViewAdapter = new WebViewAdapterImpl();

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

@@ -0,0 +1,19 @@
+export type BluetoothState = "Unknown" | "Resetting" | "Unsupported" | "Unauthorized" | "PoweredOff" | "PoweredOn";
+export interface BluetoothDevice {
+    id: string;
+    name: string | null;
+    address: string;
+    rssi?: number;
+    isConnected: boolean;
+}
+export interface BluetoothPermissionStatus {
+    scan: boolean;
+    connect: boolean;
+    advertise: boolean;
+    isGranted: boolean;
+}
+export interface BluetoothStatus {
+    isEnabled: boolean;
+    state: BluetoothState;
+    permissions: BluetoothPermissionStatus;
+}

package/dist/domain/connectivity/bluetooth.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import { DomainEvent } from "../../domain/event_sourcing/domain_event";
+export declare class InternetIsDownEvent extends DomainEvent {
+    static readonly name = "common.network.v2.internet_is_down";
+    static readonly label = "Internet desconectado";
+    static readonly requiresNetwork = false;
+    readonly name = "common.network.v2.internet_is_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 label = "Internet conectado";
+    static readonly requiresNetwork = true;
+    readonly name = "common.network.v2.internet_is_up";
+    readonly label = "Internet conectado";
+    readonly requiresNetwork = true;
+}

package/dist/domain/connectivity/events.js

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

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

@@ -0,0 +1,4 @@
+export interface Coordinates {
+    latitude: number;
+    longitude: number;
+}

package/dist/domain/connectivity/geo.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+export * from "../../domain/connectivity/bluetooth";
+export * from "../../domain/connectivity/geo";
+export * from "../../domain/connectivity/network";

package/dist/domain/connectivity/index.js

@@ -0,0 +1,3 @@
+export * from "../../domain/connectivity/bluetooth";
+export * from "../../domain/connectivity/geo";
+export * from "../../domain/connectivity/network";

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

@@ -0,0 +1,7 @@
+export type NetworkType = "UNKNOWN" | "NONE" | "WIFI" | "CELLULAR" | "ETHERNET" | "WIMAX" | "BLUETOOTH" | "VPN" | "OTHER";
+export interface NetworkStatus {
+    isConnected: boolean;
+    isInternetReachable: boolean | null;
+    type: NetworkType;
+    ipAddress: string | null;
+}

package/dist/domain/connectivity/network.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+export interface IDatabase {
+    name: string;
+    description: string;
+    tableName: string;
+}
+export interface IDatabaseTable {
+    name: string;
+}
+export interface ITable {
+    id: number;
+    data: string;
+}
+export interface IMigration {
+    name: string;
+    migrationFn: () => Promise<void>;
+}

package/dist/domain/database/database.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from "../../domain/database/database";
+export * from "../../domain/database/repository";

package/dist/domain/database/index.js

@@ -0,0 +1,2 @@
+export * from "../../domain/database/database";
+export * from "../../domain/database/repository";

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

@@ -0,0 +1,19 @@
+import { Entity, ERemoteState, RemoteEntity } from "../../domain/entity/entity";
+import { EntityCollection, ICriteria, RemoteEntityCollection } from "../../domain/entity/entity_collection";
+export interface IRepository<T extends Entity, C extends EntityCollection<T>> {
+    save(entity: T | T[] | C): Promise<void>;
+    remove(entity: T | T[]): Promise<void>;
+    findById(id: string): Promise<T | null>;
+    findByIds(ids: string[]): Promise<C>;
+    findAll(): Promise<C>;
+    findByCriteria(criteria: ICriteria<T>[]): Promise<C>;
+    findByIdSync?(id: string): T | null;
+    findByIdsSync?(ids: string[]): C;
+}
+export interface IRemoteRepository<T extends RemoteEntity> extends IRepository<T, RemoteEntityCollection<T>> {
+    findByRemoteState(state: ERemoteState | ERemoteState[]): Promise<RemoteEntityCollection<T>>;
+    findByRemoteId(remoteId: number): Promise<T | null>;
+    findByRemoteIds(remoteIds: number[]): Promise<RemoteEntityCollection<T>>;
+    findByRemoteIdSync?(remoteId: number): T | null;
+    findByRemoteIdsSync?(remoteIds: number[]): RemoteEntityCollection<T>;
+}

package/dist/domain/database/repository.js

@@ -0,0 +1 @@
+export {};