@magek/adapter-event-store-nedb 0.0.6 → 0.0.8

package/dist/event-registry.d.ts

@@ -12,4 +12,11 @@ export declare class EventRegistry {
     store(storableObject: EventEnvelope | EntitySnapshotEnvelope): Promise<void>;
     deleteAll(): Promise<number>;
     count(query?: object): Promise<number>;
+    /**
+     * Marks an event as processed by setting its processedAt timestamp.
+     *
+     * @param id - The event ID
+     * @param processedAt - The ISO timestamp when the event was processed
+     */
+    markProcessed(id: string, processedAt: string): Promise<void>;
 }

package/dist/event-registry.js

@@ -5,8 +5,9 @@ const path = require("path");
 exports.eventsDatabase = path.normalize(path.join('.', '.magek', 'events.json'));
 const DataStore = require('@seald-io/nedb');
 class EventRegistry {
+    events;
+    isLoaded = false;
     constructor() {
-        this.isLoaded = false;
         this.events = new DataStore({ filename: exports.eventsDatabase });
     }
     async loadDatabaseIfNeeded() {
@@ -66,5 +67,20 @@ class EventRegistry {
         await this.loadDatabaseIfNeeded();
         return await this.events.countAsync(query);
     }
+    /**
+     * Marks an event as processed by setting its processedAt timestamp.
+     *
+     * @param id - The event ID
+     * @param processedAt - The ISO timestamp when the event was processed
+     */
+    async markProcessed(id, processedAt) {
+        await this.loadDatabaseIfNeeded();
+        await new Promise((resolve, reject) => this.events.update({ _id: id }, { $set: { processedAt } }, {}, (err, numUpdated) => {
+            if (err)
+                reject(err);
+            else
+                resolve(numUpdated);
+        }));
+    }
 }
 exports.EventRegistry = EventRegistry;

package/dist/index.js

@@ -5,9 +5,9 @@ const event_registry_1 = require("./event-registry");
 const events_adapter_1 = require("./library/events-adapter");
 const events_search_adapter_1 = require("./library/events-search-adapter");
 const event_delete_adapter_1 = require("./library/event-delete-adapter");
+const event_processing_adapter_1 = require("./library/event-processing-adapter");
 const paths_1 = require("./paths");
 const fs_1 = require("fs");
-const path = require("path");
 // Pre-built NeDB Event Store Adapter instance
 const eventRegistry = new event_registry_1.EventRegistry();
 function notImplemented() {
@@ -16,21 +16,7 @@ function notImplemented() {
 async function countAll(database) {
     await database.loadDatabaseAsync();
     const count = await database.countAsync({});
-    return count !== null && count !== void 0 ? count : 0;
-}
-// Function to get userApp from config or load it from standard location
-function getUserApp(config) {
-    // Check if userApp is attached to config
-    if (config.userApp) {
-        return config.userApp;
-    }
-    // Fallback to loading from standard location
-    try {
-        return require(path.join(process.cwd(), 'dist', 'index.js'));
-    }
-    catch (error) {
-        throw new Error('Could not load userApp from config or standard location');
-    }
+    return count ?? 0;
 }
 exports.eventStore = {
     rawToEnvelopes: events_adapter_1.rawEventsToEnvelopes,
@@ -39,10 +25,7 @@ exports.eventStore = {
     produce: notImplemented,
     forEntitySince: (config, entityTypeName, entityID, since) => (0, events_adapter_1.readEntityEventsSince)(eventRegistry, config, entityTypeName, entityID, since),
     latestEntitySnapshot: (config, entityTypeName, entityID) => (0, events_adapter_1.readEntityLatestSnapshot)(eventRegistry, config, entityTypeName, entityID),
-    store: (eventEnvelopes, config) => {
-        const userApp = getUserApp(config);
-        return (0, events_adapter_1.storeEvents)(userApp, eventRegistry, eventEnvelopes, config);
-    },
+    store: (eventEnvelopes, config) => (0, events_adapter_1.storeEvents)(eventRegistry, eventEnvelopes, config),
     storeSnapshot: (snapshotEnvelope, config) => (0, events_adapter_1.storeSnapshot)(eventRegistry, snapshotEnvelope, config),
     search: (config, parameters) => (0, events_search_adapter_1.searchEvents)(eventRegistry, config, parameters),
     searchEntitiesIDs: (config, limit, afterCursor, entityTypeName) => (0, events_search_adapter_1.searchEntitiesIds)(eventRegistry, config, limit, afterCursor, entityTypeName),
@@ -62,4 +45,6 @@ exports.eventStore = {
         },
         urls: async () => [paths_1.eventsDatabase],
     },
+    fetchUnprocessedEvents: (config) => (0, event_processing_adapter_1.fetchUnprocessedEvents)(eventRegistry, config),
+    markEventProcessed: (config, eventId) => (0, event_processing_adapter_1.markEventProcessed)(eventRegistry, config, eventId),
 };

package/dist/library/event-processing-adapter.d.ts

@@ -0,0 +1,19 @@
+import { MagekConfig, EventEnvelope, UUID } from '@magek/common';
+import { EventRegistry } from '../event-registry';
+/**
+ * Fetches the next batch of unprocessed events.
+ * Reads cursor from file and fetches events after that position.
+ *
+ * @param eventRegistry - The event registry instance
+ * @param config - The Magek configuration object
+ * @returns An array of EventEnvelope objects
+ */
+export declare function fetchUnprocessedEvents(eventRegistry: EventRegistry, config: MagekConfig): Promise<Array<EventEnvelope>>;
+/**
+ * Marks a single event as processed and advances the cursor.
+ *
+ * @param eventRegistry - The event registry instance
+ * @param config - The Magek configuration object
+ * @param eventId - The ID of the event that was processed
+ */
+export declare function markEventProcessed(eventRegistry: EventRegistry, config: MagekConfig, eventId: UUID): Promise<void>;

package/dist/library/event-processing-adapter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUnprocessedEvents = fetchUnprocessedEvents;
+exports.markEventProcessed = markEventProcessed;
+const fs = require("fs");
+const path = require("path");
+const common_1 = require("@magek/common");
+const paths_1 = require("../paths");
+const originOfTime = new Date(0).toISOString();
+function readCursor() {
+    try {
+        if (!fs.existsSync(paths_1.eventProcessingCursorFile)) {
+            return null;
+        }
+        const data = fs.readFileSync(paths_1.eventProcessingCursorFile, 'utf-8');
+        const cursorData = JSON.parse(data);
+        return cursorData.cursor;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCursor(cursor) {
+    const cursorData = { cursor };
+    // Ensure the directory exists before writing
+    const dir = path.dirname(paths_1.eventProcessingCursorFile);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(paths_1.eventProcessingCursorFile, JSON.stringify(cursorData, null, 2), 'utf-8');
+}
+/**
+ * Fetches the next batch of unprocessed events.
+ * Reads cursor from file and fetches events after that position.
+ *
+ * @param eventRegistry - The event registry instance
+ * @param config - The Magek configuration object
+ * @returns An array of EventEnvelope objects
+ */
+async function fetchUnprocessedEvents(eventRegistry, config) {
+    const logger = (0, common_1.getLogger)(config, 'event-processing-adapter#fetchUnprocessedEvents');
+    const cursor = readCursor() ?? originOfTime;
+    const batchSize = config.eventProcessingBatchSize;
+    const query = {
+        kind: 'event',
+        deletedAt: { $exists: false },
+        processedAt: { $exists: false },
+        createdAt: { $gt: cursor },
+    };
+    logger.debug(`Fetching events after cursor ${cursor} (batch size: ${batchSize})`);
+    const result = await eventRegistry.query(query, 1, batchSize); // Sort ascending by createdAt
+    logger.debug(`Fetched ${result.length} unprocessed events`);
+    return result;
+}
+/**
+ * Marks a single event as processed and advances the cursor.
+ *
+ * @param eventRegistry - The event registry instance
+ * @param config - The Magek configuration object
+ * @param eventId - The ID of the event that was processed
+ */
+async function markEventProcessed(eventRegistry, config, eventId) {
+    const logger = (0, common_1.getLogger)(config, 'event-processing-adapter#markEventProcessed');
+    const processedAt = (0, common_1.getTimestampGenerator)().next();
+    // Fetch the event to get its createdAt for the cursor
+    const eventIdStr = eventId.toString();
+    const events = await eventRegistry.query({ _id: eventIdStr });
+    if (events.length === 0) {
+        logger.warn(`Event ${eventId} not found, cannot mark as processed`);
+        return;
+    }
+    const event = events[0];
+    logger.debug(`Marking event ${eventId} as processed at ${processedAt}`);
+    await eventRegistry.markProcessed(eventIdStr, processedAt);
+    // Update cursor to this event's createdAt timestamp
+    writeCursor(event.createdAt);
+    logger.debug(`Cursor advanced to ${event.createdAt}`);
+}

package/dist/library/events-adapter.d.ts

@@ -1,9 +1,9 @@
-import { UUID, UserApp, MagekConfig, EventEnvelope, EntitySnapshotEnvelope, NonPersistedEventEnvelope, NonPersistedEntitySnapshotEnvelope } from '@magek/common';
+import { UUID, MagekConfig, EventEnvelope, EntitySnapshotEnvelope, NonPersistedEventEnvelope, NonPersistedEntitySnapshotEnvelope } from '@magek/common';
 import { EventRegistry } from '../event-registry';
 export declare function rawEventsToEnvelopes(rawEvents: Array<unknown>): Array<EventEnvelope>;
 export declare function readEntityEventsSince(eventRegistry: EventRegistry, config: MagekConfig, entityTypeName: string, entityID: UUID, since?: string): Promise<Array<EventEnvelope>>;
 export declare function readEntityLatestSnapshot(eventRegistry: EventRegistry, config: MagekConfig, entityTypeName: string, entityID: UUID): Promise<EntitySnapshotEnvelope | undefined>;
-export declare function storeEvents(userApp: UserApp, eventRegistry: EventRegistry, nonPersistedEventEnvelopes: Array<NonPersistedEventEnvelope>, config: MagekConfig): Promise<Array<EventEnvelope>>;
+export declare function storeEvents(eventRegistry: EventRegistry, nonPersistedEventEnvelopes: Array<NonPersistedEventEnvelope>, config: MagekConfig): Promise<Array<EventEnvelope>>;
 export declare function storeSnapshot(eventRegistry: EventRegistry, snapshotEnvelope: NonPersistedEntitySnapshotEnvelope, config: MagekConfig): Promise<EntitySnapshotEnvelope>;
 /**
  * Dummy method that'll always return true, since local provider won't be tracking dispatched events

package/dist/library/events-adapter.js

@@ -46,20 +46,16 @@ async function readEntityLatestSnapshot(eventRegistry, config, entityTypeName, e
         return undefined;
     }
 }
-async function storeEvents(userApp, eventRegistry, nonPersistedEventEnvelopes, config) {
+async function storeEvents(eventRegistry, nonPersistedEventEnvelopes, config) {
     const logger = (0, common_1.getLogger)(config, 'events-adapter#storeEvents');
     logger.debug('Storing the following event envelopes:', nonPersistedEventEnvelopes);
     const persistedEventEnvelopes = [];
     for (const nonPersistedEventEnvelope of nonPersistedEventEnvelopes) {
-        const persistableEventEnvelope = {
-            ...nonPersistedEventEnvelope,
-            createdAt: new Date().toISOString(),
-        };
+        const persistableEventEnvelope = nonPersistedEventEnvelope;
         await (0, common_1.retryIfError)(async () => await persistEvent(eventRegistry, persistableEventEnvelope), common_1.OptimisticConcurrencyUnexpectedVersionError);
         persistedEventEnvelopes.push(persistableEventEnvelope);
     }
     logger.debug('EventEnvelopes stored: ', persistedEventEnvelopes);
-    await userApp.eventDispatcher(persistedEventEnvelopes);
     return persistedEventEnvelopes;
 }
 async function storeSnapshot(eventRegistry, snapshotEnvelope, config) {
@@ -68,7 +64,7 @@ async function storeSnapshot(eventRegistry, snapshotEnvelope, config) {
     const persistableEntitySnapshot = {
         ...snapshotEnvelope,
         createdAt: snapshotEnvelope.snapshottedEventCreatedAt,
-        persistedAt: new Date().toISOString(),
+        persistedAt: (0, common_1.getTimestampGenerator)().next(),
     };
     await (0, common_1.retryIfError)(() => eventRegistry.store(persistableEntitySnapshot), common_1.OptimisticConcurrencyUnexpectedVersionError);
     logger.debug('Snapshot stored');

package/dist/library/events-search-adapter.js

@@ -18,7 +18,6 @@ async function searchEvents(eventRegistry, config, parameters) {
     return eventsSearchResponses;
 }
 async function searchEntitiesIds(eventRegistry, config, limit, afterCursor, entityTypeName) {
-    var _a;
     const logger = (0, common_1.getLogger)(config, 'events-searcher-adapter#searchEntitiesIds');
     logger.debug(`Initiating a paginated events search. limit: ${limit}, afterCursor: ${JSON.stringify(afterCursor)}, entityTypeName: ${entityTypeName}`);
     const filterQuery = {
@@ -30,15 +29,15 @@ async function searchEntitiesIds(eventRegistry, config, limit, afterCursor, enti
         entityID: 1,
     }));
     // Nedb doesn't support DISTINCT, so we need to paginate the results manually
-    const entitiesIds = result ? result === null || result === void 0 ? void 0 : result.map((v) => v.entityID) : [];
+    const entitiesIds = result ? result?.map((v) => v.entityID) : [];
     const uniqueResult = (0, common_1.unique)(entitiesIds);
-    const skipId = (afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) ? parseInt(afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) : 0;
+    const skipId = afterCursor?.id ? parseInt(afterCursor?.id) : 0;
     const paginated = uniqueResult.slice(skipId, skipId + limit);
     const paginatedResult = paginated.map((v) => ({ entityID: v }));
     logger.debug('Unique events search result', paginatedResult);
     return {
         items: paginatedResult,
-        count: (_a = paginatedResult === null || paginatedResult === void 0 ? void 0 : paginatedResult.length) !== null && _a !== void 0 ? _a : 0,
+        count: paginatedResult?.length ?? 0,
         cursor: { id: ((limit ? limit : 1) + skipId).toString() },
     };
 }

package/dist/library/events-searcher-builder.js

@@ -50,7 +50,7 @@ function resultToEventSearchResponse(result) {
             deletedAt: item.deletedAt,
         };
     });
-    return eventSearchResult !== null && eventSearchResult !== void 0 ? eventSearchResult : [];
+    return eventSearchResult ?? [];
 }
 function buildByEntityAndID(entityValue, entityIdValue) {
     return {

package/dist/paths.d.ts

@@ -1 +1,2 @@
 export declare const eventsDatabase: string;
+export declare const eventProcessingCursorFile: string;

package/dist/paths.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventsDatabase = void 0;
+exports.eventProcessingCursorFile = exports.eventsDatabase = void 0;
 const path = require("path");
 exports.eventsDatabase = internalPath('events.json');
+exports.eventProcessingCursorFile = internalPath('event-processing-cursor.json');
 function internalPath(filename) {
     return path.normalize(path.join('.', '.magek', filename));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magek/adapter-event-store-nedb",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Nedb-based event store adapter for the Magek framework",
   "keywords": [
     "event-store",
@@ -24,7 +24,7 @@
     "node": ">=22.0.0 <23.0.0"
   },
   "dependencies": {
-    "@magek/common": "^0.0.6",
+    "@magek/common": "^0.0.8",
     "@seald-io/nedb": "4.1.2",
     "tslib": "2.8.1"
   },
@@ -32,7 +32,7 @@
     "url": "https://github.com/theam/magek/issues"
   },
   "devDependencies": {
-    "@magek/eslint-config": "^0.0.6",
+    "@magek/eslint-config": "^0.0.8",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",