@teincfood/core 0.1.1 → 0.1.3

package/dist/reference/service.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Reference Data Synchronization Service.
  *
@@ -8,15 +7,13 @@
  * This service is separate from the Sync Engine, which handles transactional
  * commands and events.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.referenceSyncService = void 0;
-const connection_1 = require("../db/connection");
-const sync_logger_1 = require("../utils/sync-logger");
-const uuid_1 = require("../utils/uuid");
-const services_1 = require("../adapters/services");
-const image_cache_1 = require("../adapters/image-cache");
-const operations_1 = require("./operations");
-const api_1 = require("./api");
+import { openSyncDatabase } from "../db/connection";
+import { syncLogger } from "../utils/sync-logger";
+import { generateUUID } from "../utils/uuid";
+import { menuService, businessService, rolesService } from "../adapters/services";
+import { cacheImageBatch, pruneImageCache } from "../adapters/image-cache";
+import { getReferenceData, getReferenceVersion, setReferenceData, } from "./operations";
+import { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, } from "./api";
 const DEFAULT_SYNC_KEYS = [
     "menu:items",
     "menu:categories",
@@ -41,7 +38,7 @@ class ReferenceSyncService {
             };
         }
         this.isSyncing = true;
-        sync_logger_1.syncLogger.info("ReferenceSync", "Starting reference data sync", {
+        syncLogger.info("ReferenceSync", "Starting reference data sync", {
             businessId: options.businessId,
             keys: options.keys,
         });
@@ -52,16 +49,16 @@ class ReferenceSyncService {
             errors: {},
         };
         try {
-            const db = await (0, connection_1.openSyncDatabase)();
+            const db = await openSyncDatabase();
             const keys = options.keys ?? DEFAULT_SYNC_KEYS;
             // Attempt version-aware sync. If the backend does not support versioning
             // endpoints, fall back to legacy full-fetch per key.
             let versions = null;
             try {
-                versions = await (0, api_1.fetchReferenceVersions)(options.businessId);
+                versions = await fetchReferenceVersions(options.businessId);
             }
             catch (error) {
-                sync_logger_1.syncLogger.warn("ReferenceSync", "Version endpoint unavailable, using fallback", {
+                syncLogger.warn("ReferenceSync", "Version endpoint unavailable, using fallback", {
                     error: String(error),
                 });
             }
@@ -78,7 +75,7 @@ class ReferenceSyncService {
                 catch (error) {
                     result.failed.push(key);
                     result.errors[key] = String(error);
-                    sync_logger_1.syncLogger.error("ReferenceSync", `Failed to sync ${key}`, {
+                    syncLogger.error("ReferenceSync", `Failed to sync ${key}`, {
                         error: String(error),
                     });
                 }
@@ -93,7 +90,7 @@ class ReferenceSyncService {
         finally {
             this.isSyncing = false;
         }
-        sync_logger_1.syncLogger.info("ReferenceSync", "Reference data sync complete", {
+        syncLogger.info("ReferenceSync", "Reference data sync complete", {
             synced: result.synced,
             skipped: result.skipped,
             failed: result.failed,
@@ -102,7 +99,7 @@ class ReferenceSyncService {
     }
     async syncKey(db, key, options, versions) {
         const { businessId } = options;
-        const localVersion = await (0, operations_1.getReferenceVersion)(db, businessId, key);
+        const localVersion = await getReferenceVersion(db, businessId, key);
         // A key the backend does not version (e.g. during a gradual rollout) is
         // fetched with a full fetch + local hash so it is still cached offline.
         const serverVersion = versions?.find((v) => v.key === key)?.version;
@@ -110,7 +107,7 @@ class ReferenceSyncService {
             // In non-incremental mode without force, we still re-sync if version
             // info says there is a newer version on the server.
             if (serverVersion && serverVersion === localVersion) {
-                sync_logger_1.syncLogger.debug("ReferenceSync", `Up to date: ${key}`, {
+                syncLogger.debug("ReferenceSync", `Up to date: ${key}`, {
                     version: localVersion,
                 });
                 return false;
@@ -121,19 +118,19 @@ class ReferenceSyncService {
         if (versions && serverVersion) {
             if (localVersion && serverVersion !== localVersion) {
                 try {
-                    const changeSet = await (0, api_1.fetchReferenceChanges)(businessId, key, localVersion);
+                    const changeSet = await fetchReferenceChanges(businessId, key, localVersion);
                     payload = changeSet.changes;
                     version = changeSet.to_version;
                 }
                 catch {
                     // Fall back to full fetch if changes endpoint fails.
-                    const data = await (0, api_1.fetchReferenceData)(businessId, [key]);
+                    const data = await fetchReferenceData(businessId, [key]);
                     payload = data[key];
                     version = serverVersion;
                 }
             }
             else {
-                const data = await (0, api_1.fetchReferenceData)(businessId, [key]);
+                const data = await fetchReferenceData(businessId, [key]);
                 payload = data[key];
                 version = serverVersion;
             }
@@ -145,12 +142,12 @@ class ReferenceSyncService {
             payload = fallback.payload;
             version = fallback.version;
         }
-        await (0, operations_1.setReferenceData)(db, businessId, {
+        await setReferenceData(db, businessId, {
             key,
             // Defensive: never write a NULL version. If the backend ever omits the
             // version, generate one so the row is still usable; the next version
             // comparison will simply see a mismatch and re-sync.
-            version: version ?? (0, uuid_1.generateUUID)(),
+            version: version ?? generateUUID(),
             payload,
             downloadedAt: new Date().toISOString(),
         });
@@ -159,49 +156,49 @@ class ReferenceSyncService {
     async fetchFallback(key, businessId) {
         switch (key) {
             case "menu:items": {
-                const response = await services_1.menuService.fetchBusinessMenuItems(businessId, 1);
+                const response = await menuService.fetchBusinessMenuItems(businessId, 1);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "menu:categories": {
-                const response = await services_1.menuService.fetchBusinessCategories(businessId);
+                const response = await menuService.fetchBusinessCategories(businessId);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "roles": {
-                const response = await services_1.rolesService.fetchBusinessRoles();
+                const response = await rolesService.fetchBusinessRoles();
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "members": {
-                const response = await services_1.businessService.fetchBusinessMembers(businessId);
+                const response = await businessService.fetchBusinessMembers(businessId);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "tax-rules": {
-                const response = await services_1.businessService.fetchBusinessTaxRules(businessId);
+                const response = await businessService.fetchBusinessTaxRules(businessId);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "business:profile": {
-                const response = await services_1.businessService.fetchBusinessById(businessId);
+                const response = await businessService.fetchBusinessById(businessId);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
                 };
             }
             case "operating-hours": {
-                const response = await services_1.businessService.fetchOperatingHours(businessId);
+                const response = await businessService.fetchOperatingHours(businessId);
                 return {
                     payload: response,
                     version: this.hashPayload(response),
@@ -221,12 +218,12 @@ class ReferenceSyncService {
         try {
             const urls = [];
             if (keys.includes("menu:items")) {
-                const cached = await (0, operations_1.getReferenceData)(db, businessId, "menu:items");
+                const cached = await getReferenceData(db, businessId, "menu:items");
                 const items = cached?.payload?.data ?? [];
                 urls.push(...items.map((item) => item.image_url));
             }
             if (keys.includes("business:profile")) {
-                const cached = await (0, operations_1.getReferenceData)(db, businessId, "business:profile");
+                const cached = await getReferenceData(db, businessId, "business:profile");
                 const business = cached?.payload?.data;
                 if (business) {
                     urls.push(business.logo_url, business.cover_image_url);
@@ -234,18 +231,18 @@ class ReferenceSyncService {
             }
             if (urls.length === 0)
                 return;
-            const cachedImages = await (0, image_cache_1.cacheImageBatch)(urls, {
+            const cachedImages = await cacheImageBatch(urls, {
                 skipIfCached: true,
             });
-            sync_logger_1.syncLogger.debug("ReferenceSync", "Reference images cached", {
+            syncLogger.debug("ReferenceSync", "Reference images cached", {
                 businessId,
                 keys,
                 count: cachedImages.length,
             });
-            await (0, image_cache_1.pruneImageCache)(urls);
+            await pruneImageCache(urls);
         }
         catch (error) {
-            sync_logger_1.syncLogger.warn("ReferenceSync", "Failed to cache reference images", {
+            syncLogger.warn("ReferenceSync", "Failed to cache reference images", {
                 error: String(error),
             });
         }
@@ -263,8 +260,8 @@ class ReferenceSyncService {
         return `local-${Math.abs(hash).toString(16)}`;
     }
     async getCached(businessId, key) {
-        const db = await (0, connection_1.openSyncDatabase)();
-        return (0, operations_1.getReferenceData)(db, businessId, key);
+        const db = await openSyncDatabase();
+        return getReferenceData(db, businessId, key);
     }
 }
-exports.referenceSyncService = new ReferenceSyncService();
+export const referenceSyncService = new ReferenceSyncService();

package/dist/reference/types.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Types for reference data synchronization.
  *
@@ -9,4 +8,4 @@
  * It is synchronized separately from transactional data through the
  * ReferenceSyncService.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/repositories/order.repository.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Order Repository.
  *
@@ -8,10 +7,8 @@
  * In Phase 1, commands execute immediately through the REST transport.
  * Future phases will queue commands when offline.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderRepository = void 0;
-const engine_1 = require("../sync/engine");
-const command_builder_1 = require("../sync/command-builder");
+import { syncEngine } from "../sync/engine";
+import { buildCommand } from "../sync/command-builder";
 async function executeCommand(command) {
     console.debug("[OrderRepository] Dispatching command", JSON.stringify({
         command_id: command.command_id,
@@ -21,7 +18,7 @@ async function executeCommand(command) {
         payload_keys: Object.keys(command.payload ?? {}),
         timestamp: new Date().toISOString(),
     }));
-    const events = await engine_1.syncEngine.execute(command);
+    const events = await syncEngine.execute(command);
     const event = events[0];
     console.debug("[OrderRepository] Command result", JSON.stringify({
         command_id: command.command_id,
@@ -37,9 +34,9 @@ async function executeCommand(command) {
     }
     return event.payload;
 }
-exports.orderRepository = {
+export const orderRepository = {
     async createOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:create",
             businessId: input.businessId,
             entityId: input.entityId,
@@ -48,7 +45,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async acceptOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:accept",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -57,7 +54,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async rejectOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:reject",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -66,7 +63,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async startPreparingOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:start_preparing",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -75,7 +72,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async markOrderReady(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:mark_ready",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -84,7 +81,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async completePickup(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:complete_pickup",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -93,7 +90,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async cancelOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:cancel",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -102,13 +99,13 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async confirmHandover(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "delivery:confirm_handover",
             businessId: input.businessId,
             entityId: input.deliveryId,
             payload: {},
         });
-        const events = await engine_1.syncEngine.execute(command);
+        const events = await syncEngine.execute(command);
         const event = events[0];
         if (!event) {
             throw new Error("OrderRepository: confirmHandover returned no events");
@@ -116,13 +113,13 @@ exports.orderRepository = {
         return event.payload;
     },
     async assignRider(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "delivery:assign",
             businessId: input.businessId,
             entityId: input.orderId,
             payload: { rider_id: input.riderId },
         });
-        const events = await engine_1.syncEngine.execute(command);
+        const events = await syncEngine.execute(command);
         const event = events[0];
         if (!event) {
             throw new Error("OrderRepository: assignRider returned no events");

package/dist/repositories/pos.repository.js

@@ -1,20 +1,17 @@
-"use strict";
 /**
  * POS Repository.
  *
  * Domain-specific operations for the POS terminal. Builds on OrderRepository
  * for commands and keeps read/query operations behind a repository interface.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.posRepository = void 0;
-const services_1 = require("../adapters/services");
-const order_repository_1 = require("./order.repository");
-exports.posRepository = {
+import { posService } from "../adapters/services";
+import { orderRepository } from "./order.repository";
+export const posRepository = {
     async createOrder(businessId, data, entityId) {
-        return order_repository_1.orderRepository.createOrder({ businessId, data, entityId });
+        return orderRepository.createOrder({ businessId, data, entityId });
     },
     async fetchPreview(input) {
-        const res = await services_1.posService.fetchPOSOrderPreview(input.businessId, {
+        const res = await posService.fetchPOSOrderPreview(input.businessId, {
             items: input.items,
             order_type: input.orderType,
             customer_name: input.customerName,
@@ -22,7 +19,7 @@ exports.posRepository = {
         return res;
     },
     async fetchOrders(businessId, params) {
-        const res = await services_1.posService.fetchBusinessOrders(businessId, params);
+        const res = await posService.fetchBusinessOrders(businessId, params);
         return res;
     },
 };

package/dist/sync/command-builder.js

@@ -1,23 +1,18 @@
-"use strict";
 /**
  * Command builder helpers.
  *
  * Centralizes creation of Command objects with consistent metadata
  * (command_id, user_id, device_id, timestamps).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAppInstanceId = void 0;
-exports.buildCommand = buildCommand;
-const auth_1 = require("../adapters/auth");
-const devices_1 = require("../adapters/devices");
-Object.defineProperty(exports, "getAppInstanceId", { enumerable: true, get: function () { return devices_1.getAppInstanceId; } });
-const uuid_1 = require("../utils/uuid");
-function buildCommand(options) {
-    const user = auth_1.useAuthStore.getState().user;
+import { useAuthStore } from "../adapters/auth";
+import { getAppInstanceId } from "../adapters/devices";
+import { generateCommandId } from "../utils/uuid";
+export function buildCommand(options) {
+    const user = useAuthStore.getState().user;
     const userId = user?.id ?? "anonymous";
-    const deviceId = (0, devices_1.getAppInstanceId)();
+    const deviceId = getAppInstanceId();
     return {
-        command_id: (0, uuid_1.generateCommandId)(),
+        command_id: generateCommandId(),
         command_type: options.commandType,
         command_version: options.commandVersion ?? "1.0",
         business_id: options.businessId,
@@ -28,3 +23,4 @@ function buildCommand(options) {
         payload: options.payload,
     };
 }
+export { getAppInstanceId };

package/dist/sync/command-queue.service.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Command Queue Service.
  *
@@ -9,18 +8,16 @@
  *   - Replay queued commands when a transport becomes available.
  *   - Provide optimistic domain events so the UI can render pending orders.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandQueueService = void 0;
-const connection_1 = require("../db/connection");
-const operations_1 = require("../db/operations");
-const sync_logger_1 = require("../utils/sync-logger");
-const uuid_1 = require("../utils/uuid");
-const order_number_1 = require("./order-number");
+import { getSyncDatabase, openSyncDatabase } from "../db/connection";
+import { insertCommand, getPendingCommands, markCommandInFlight, updateCommandStatus, deleteCommand, insertEvent, } from "../db/operations";
+import { syncLogger } from "../utils/sync-logger";
+import { generateEventId } from "../utils/uuid";
+import { generateLocalOrderNumber, generateLocalCalloutNumber, } from "./order-number";
 const MAX_RETRIES = 5;
 function buildOptimisticEvent(command) {
     const payload = command.payload;
     return {
-        event_id: (0, uuid_1.generateEventId)(),
+        event_id: generateEventId(),
         event_type: `${command.command_type.replace(":", ".")}_queued`,
         event_version: "1.0",
         entity_id: command.entity_id ?? command.command_id,
@@ -40,11 +37,11 @@ function buildOptimisticOrder(command, payload) {
     const items = payload.items ?? [];
     const totalMinor = payload.total_minor ?? 0;
     const now = new Date().toISOString();
-    const orderNumber = payload.order_number ?? (0, order_number_1.generateLocalOrderNumber)();
+    const orderNumber = payload.order_number ?? generateLocalOrderNumber();
     return {
         id: command.entity_id ?? command.command_id,
         order_number: orderNumber,
-        callout_number: (0, order_number_1.generateLocalCalloutNumber)(),
+        callout_number: generateLocalCalloutNumber(),
         order_type: payload.order_type ?? "takeout",
         is_pos: true,
         customer_name: payload.customer_name ?? null,
@@ -104,7 +101,7 @@ function injectLocalOrderNumber(command) {
         ...command,
         payload: {
             ...payload,
-            order_number: (0, order_number_1.generateLocalOrderNumber)(),
+            order_number: generateLocalOrderNumber(),
         },
     };
 }
@@ -121,19 +118,19 @@ class CommandQueueService {
      * Returns an optimistic domain event so the caller can update the UI.
      */
     async enqueue(command) {
-        const db = (0, connection_1.getSyncDatabase)();
+        const db = getSyncDatabase();
         const preparedCommand = injectLocalOrderNumber(command);
-        await (0, operations_1.insertCommand)(db, { command: preparedCommand, status: "pending" });
-        sync_logger_1.syncLogger.command(preparedCommand, "queued");
-        const pending = await (0, operations_1.getPendingCommands)(db, Number.MAX_SAFE_INTEGER);
-        sync_logger_1.syncLogger.info("CommandQueueService", "Command queued offline", {
+        await insertCommand(db, { command: preparedCommand, status: "pending" });
+        syncLogger.command(preparedCommand, "queued");
+        const pending = await getPendingCommands(db, Number.MAX_SAFE_INTEGER);
+        syncLogger.info("CommandQueueService", "Command queued offline", {
             command_id: preparedCommand.command_id,
             command_type: preparedCommand.command_type,
             order_number: preparedCommand.payload.order_number ?? null,
             outbox_size: pending.length,
         });
         const event = buildOptimisticEvent(preparedCommand);
-        sync_logger_1.syncLogger.info("CommandQueueService", "Optimistic event built", {
+        syncLogger.info("CommandQueueService", "Optimistic event built", {
             event_type: event.event_type,
             entity_id: event.entity_id,
             order_number: event.payload.order_number ?? null,
@@ -143,10 +140,10 @@ class CommandQueueService {
         // rehydrated (and shown) while still offline.
         if (preparedCommand.command_type === "order:create") {
             try {
-                await (0, operations_1.insertEvent)(db, { event, origin: "local" });
+                await insertEvent(db, { event, origin: "local" });
             }
             catch (error) {
-                sync_logger_1.syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
+                syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
                     error: String(error),
                 });
             }
@@ -157,7 +154,7 @@ class CommandQueueService {
      * Try to execute a single pending command through the current transport.
      */
     async processCommand(command) {
-        const db = (0, connection_1.getSyncDatabase)();
+        const db = getSyncDatabase();
         const parsedCommand = {
             command_id: command.command_id,
             command_type: command.command_type,
@@ -170,20 +167,20 @@ class CommandQueueService {
             payload: command.payload,
         };
         if (command.retry_count >= MAX_RETRIES) {
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "failed", "Max retry count exceeded");
+            await updateCommandStatus(db, command.command_id, "failed", "Max retry count exceeded");
             return;
         }
         if (!this.syncEngine) {
             throw new Error("CommandQueueService: SyncEngine not initialized");
         }
-        await (0, operations_1.markCommandInFlight)(db, command.command_id);
+        await markCommandInFlight(db, command.command_id);
         try {
             const events = await this.syncEngine.execute(parsedCommand);
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "completed");
-            sync_logger_1.syncLogger.command(parsedCommand, "completed", {
+            await updateCommandStatus(db, command.command_id, "completed");
+            syncLogger.command(parsedCommand, "completed", {
                 event_count: events.length,
             });
-            sync_logger_1.syncLogger.info("CommandQueueService", "Queued command replayed", {
+            syncLogger.info("CommandQueueService", "Queued command replayed", {
                 command_id: command.command_id,
                 command_type: command.command_type,
                 event_count: events.length,
@@ -191,8 +188,8 @@ class CommandQueueService {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "failed", message);
-            sync_logger_1.syncLogger.command(parsedCommand, "failed", { error: message });
+            await updateCommandStatus(db, command.command_id, "failed", message);
+            syncLogger.command(parsedCommand, "failed", { error: message });
             throw error;
         }
     }
@@ -202,7 +199,7 @@ class CommandQueueService {
      */
     async replay() {
         if (this.replaying) {
-            sync_logger_1.syncLogger.debug("CommandQueueService", "Replay already in progress");
+            syncLogger.debug("CommandQueueService", "Replay already in progress");
             return;
         }
         this.replaying = true;
@@ -210,11 +207,11 @@ class CommandQueueService {
             // Await open (not getSyncDatabase) so a cold-start replay triggered by a
             // connectivity event that fires before the DB open completes does not
             // throw "Sync database not initialized".
-            const db = await (0, connection_1.openSyncDatabase)();
-            const pending = await (0, operations_1.getPendingCommands)(db);
+            const db = await openSyncDatabase();
+            const pending = await getPendingCommands(db);
             if (pending.length === 0)
                 return;
-            sync_logger_1.syncLogger.info("CommandQueueService", "Replaying commands", {
+            syncLogger.info("CommandQueueService", "Replaying commands", {
                 count: pending.length,
             });
             for (const command of pending) {
@@ -235,9 +232,9 @@ class CommandQueueService {
      * Cancel a queued command that has not yet been transmitted.
      */
     async cancel(commandId) {
-        const db = (0, connection_1.getSyncDatabase)();
-        await (0, operations_1.deleteCommand)(db, commandId);
-        sync_logger_1.syncLogger.debug("CommandQueueService", "Command cancelled", {
+        const db = getSyncDatabase();
+        await deleteCommand(db, commandId);
+        syncLogger.debug("CommandQueueService", "Command cancelled", {
             commandId,
         });
     }
@@ -245,9 +242,9 @@ class CommandQueueService {
      * Return the number of commands currently in the outbox.
      */
     async getPendingCount() {
-        const db = (0, connection_1.getSyncDatabase)();
-        const commands = await (0, operations_1.getPendingCommands)(db, Number.MAX_SAFE_INTEGER);
+        const db = getSyncDatabase();
+        const commands = await getPendingCommands(db, Number.MAX_SAFE_INTEGER);
         return commands.length;
     }
 }
-exports.commandQueueService = new CommandQueueService();
+export const commandQueueService = new CommandQueueService();