@magek/adapter-event-store-nedb 0.0.1

package/dist/event-registry.d.ts

@@ -0,0 +1,15 @@
+import { EntitySnapshotEnvelope, EventEnvelope, EventStoreEntryEnvelope } from '@magek/common';
+export declare const eventsDatabase: string;
+export declare class EventRegistry {
+    readonly events: any;
+    isLoaded: boolean;
+    constructor();
+    loadDatabaseIfNeeded(): Promise<void>;
+    getCursor(query: object, createdAt?: number, projections?: unknown): any;
+    query(query: object, createdAt?: number, limit?: number, projections?: unknown): Promise<EventStoreEntryEnvelope[]>;
+    replaceOrDeleteItem(id: string, newValue?: EventEnvelope | EntitySnapshotEnvelope): Promise<void>;
+    queryLatestSnapshot(query: object): Promise<EntitySnapshotEnvelope | undefined>;
+    store(storableObject: EventEnvelope | EntitySnapshotEnvelope): Promise<void>;
+    deleteAll(): Promise<number>;
+    count(query?: object): Promise<number>;
+}

package/dist/event-registry.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRegistry = exports.eventsDatabase = void 0;
+const path = require("path");
+exports.eventsDatabase = path.normalize(path.join('.', '.magek', 'events.json'));
+const DataStore = require('@seald-io/nedb');
+class EventRegistry {
+    constructor() {
+        this.isLoaded = false;
+        this.events = new DataStore({ filename: exports.eventsDatabase });
+    }
+    async loadDatabaseIfNeeded() {
+        if (!this.isLoaded) {
+            this.isLoaded = true;
+            await this.events.loadDatabaseAsync();
+        }
+    }
+    getCursor(query, createdAt = 1, projections) {
+        const cursor = this.events.findAsync(query, projections);
+        return cursor.sort({ createdAt: createdAt });
+    }
+    async query(query, createdAt = 1, limit, projections) {
+        await this.loadDatabaseIfNeeded();
+        let cursor = this.getCursor(query, createdAt, projections);
+        if (limit) {
+            cursor = cursor.limit(Number(limit));
+        }
+        return await cursor.execAsync();
+    }
+    async replaceOrDeleteItem(id, newValue) {
+        if (newValue) {
+            await new Promise((resolve, reject) => this.events.update({ _id: id }, newValue, { multi: true }, (err, numRemoved) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(numRemoved);
+            }));
+        }
+        else {
+            await new Promise((resolve, reject) => this.events.remove({ _id: id }, { multi: true }, (err, numRemoved) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(numRemoved);
+            }));
+        }
+    }
+    async queryLatestSnapshot(query) {
+        await this.loadDatabaseIfNeeded();
+        const cursor = this.events.findAsync({ ...query, kind: 'snapshot' }).sort({ snapshottedEventCreatedAt: -1 }); // Sort in descending order (newer timestamps first)
+        const results = await cursor.execAsync();
+        if (results.length <= 0) {
+            return undefined;
+        }
+        return results[0];
+    }
+    async store(storableObject) {
+        await this.loadDatabaseIfNeeded();
+        await this.events.insertAsync(storableObject);
+    }
+    async deleteAll() {
+        await this.loadDatabaseIfNeeded();
+        return await this.events.removeAsync({}, { multi: true });
+    }
+    async count(query) {
+        await this.loadDatabaseIfNeeded();
+        return await this.events.countAsync(query);
+    }
+}
+exports.EventRegistry = EventRegistry;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { EventStoreAdapter } from '@magek/common';
+export declare const eventStore: EventStoreAdapter;

package/dist/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventStore = void 0;
+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 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() {
+    throw new Error('Not implemented for NeDB adapter');
+}
+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');
+    }
+}
+exports.eventStore = {
+    rawToEnvelopes: events_adapter_1.rawEventsToEnvelopes,
+    rawStreamToEnvelopes: notImplemented,
+    dedupEventStream: notImplemented,
+    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);
+    },
+    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),
+    storeDispatched: () => (0, events_adapter_1.storeDispatchedEvent)(),
+    findDeletableEvent: (config, parameters) => (0, event_delete_adapter_1.findDeletableEvent)(eventRegistry, config, parameters),
+    findDeletableSnapshot: (config, parameters) => (0, event_delete_adapter_1.findDeletableSnapshot)(eventRegistry, config, parameters),
+    deleteEvent: (config, events) => (0, event_delete_adapter_1.deleteEvent)(eventRegistry, config, events),
+    deleteSnapshot: (config, snapshots) => (0, event_delete_adapter_1.deleteSnapshot)(eventRegistry, config, snapshots),
+    healthCheck: {
+        isUp: async () => (0, fs_1.existsSync)(paths_1.eventsDatabase),
+        details: async () => {
+            const count = await countAll(eventRegistry.events);
+            return {
+                file: paths_1.eventsDatabase,
+                count: count,
+            };
+        },
+        urls: async () => [paths_1.eventsDatabase],
+    },
+};

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

@@ -0,0 +1,18 @@
+import { MagekConfig, EventDeleteParameters, SnapshotDeleteParameters, EventEnvelopeFromDatabase, EntitySnapshotEnvelopeFromDatabase } from '@magek/common';
+import { EventRegistry } from '../event-registry';
+export type QueryValue = number | string | boolean;
+export type QueryOperation<TValue> = TValue | {
+    $lt?: TValue;
+    $lte?: TValue;
+    $gt?: TValue;
+    $gte?: TValue;
+    $ne?: TValue;
+    $in?: Array<TValue>;
+    $nin?: Array<TValue>;
+    $exists?: boolean;
+    $regex?: RegExp | string;
+};
+export declare function findDeletableEvent(eventRegistry: EventRegistry, config: MagekConfig, parameters: EventDeleteParameters): Promise<Array<EventEnvelopeFromDatabase>>;
+export declare function findDeletableSnapshot(eventRegistry: EventRegistry, config: MagekConfig, parameters: SnapshotDeleteParameters): Promise<Array<EntitySnapshotEnvelopeFromDatabase>>;
+export declare function deleteEvent(eventRegistry: EventRegistry, config: MagekConfig, events: Array<EventEnvelopeFromDatabase>): Promise<void>;
+export declare function deleteSnapshot(eventRegistry: EventRegistry, config: MagekConfig, snapshots: Array<EntitySnapshotEnvelopeFromDatabase>): Promise<void>;

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDeletableEvent = findDeletableEvent;
+exports.findDeletableSnapshot = findDeletableSnapshot;
+exports.deleteEvent = deleteEvent;
+exports.deleteSnapshot = deleteSnapshot;
+const common_1 = require("@magek/common");
+async function findDeletableEvent(eventRegistry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'events-delete-adapter#findDeletableEvent');
+    const stringifyParameters = JSON.stringify(parameters);
+    logger.debug(`Initiating a deletable event search for ${stringifyParameters}`);
+    const filter = buildDeleteEventFilter(parameters.entityTypeName, parameters.entityID, parameters.createdAt);
+    const events = (await eventRegistry.query(filter));
+    const result = events.map((event) => {
+        return {
+            ...event,
+            id: event._id,
+        };
+    });
+    logger.debug(`Finished deletable event search for ${stringifyParameters}`);
+    return result;
+}
+async function findDeletableSnapshot(eventRegistry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'events-delete-adapter#findDeletableSnapshot');
+    const stringifyParameters = JSON.stringify(parameters);
+    logger.debug(`Initiating a deletable snapshot search for ${stringifyParameters}`);
+    const filter = buildDeleteEntityFilter(parameters.entityTypeName, parameters.entityID, parameters.createdAt);
+    const snapshots = (await eventRegistry.query(filter));
+    const result = snapshots.map((snapshot) => {
+        return {
+            ...snapshot,
+            id: snapshot._id,
+        };
+    });
+    logger.debug(`Finished deletable snapshot search for ${stringifyParameters}`);
+    return result;
+}
+async function deleteEvent(eventRegistry, config, events) {
+    const logger = (0, common_1.getLogger)(config, 'events-delete-adapter#deleteEvent');
+    const stringifyParameters = JSON.stringify(events);
+    logger.debug(`Initiating an event delete for ${stringifyParameters}`);
+    if (!events || events.length === 0) {
+        logger.warn('Could not find events to delete');
+        return;
+    }
+    for (const event of events) {
+        const newEvent = buildNewEvent(event);
+        await eventRegistry.replaceOrDeleteItem(event.id, newEvent);
+    }
+    logger.debug(`Finished event delete for ${stringifyParameters}`);
+}
+async function deleteSnapshot(eventRegistry, config, snapshots) {
+    const logger = (0, common_1.getLogger)(config, 'events-delete-adapter#deleteSnapshot');
+    const stringifyParameters = JSON.stringify(snapshots);
+    logger.debug(`Initiating a snapshot delete for ${stringifyParameters}`);
+    if (!snapshots || snapshots.length === 0) {
+        logger.warn('Could not find snapshot to delete');
+        return;
+    }
+    for (const snapshot of snapshots) {
+        await eventRegistry.replaceOrDeleteItem(snapshot.id);
+    }
+    logger.debug(`Finished snapshot delete for ${stringifyParameters}`);
+}
+function buildNewEvent(existingEvent) {
+    return {
+        ...existingEvent,
+        deletedAt: new Date().toISOString(),
+        value: {},
+    };
+}
+function buildDeleteEventFilter(entityTypeName, entityId, createdAt) {
+    return {
+        entityID: entityId.toString(),
+        entityTypeName: entityTypeName,
+        createdAt: createdAt,
+        kind: 'event',
+        deletedAt: { $exists: false },
+    };
+}
+function buildDeleteEntityFilter(entityTypeName, entityId, createdAt) {
+    return {
+        entityTypeName: entityTypeName,
+        entityID: entityId.toString(),
+        kind: 'snapshot',
+        createdAt: createdAt,
+        deletedAt: { $exists: false },
+    };
+}

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

@@ -0,0 +1,12 @@
+import { UUID, UserApp, 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 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
+ */
+export declare function storeDispatchedEvent(): Promise<boolean>;
+export declare function getDatabaseEventsHealthDetails(eventRegistry: EventRegistry): Promise<unknown>;

package/dist/library/events-adapter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawEventsToEnvelopes = rawEventsToEnvelopes;
+exports.readEntityEventsSince = readEntityEventsSince;
+exports.readEntityLatestSnapshot = readEntityLatestSnapshot;
+exports.storeEvents = storeEvents;
+exports.storeSnapshot = storeSnapshot;
+exports.storeDispatchedEvent = storeDispatchedEvent;
+exports.getDatabaseEventsHealthDetails = getDatabaseEventsHealthDetails;
+const common_1 = require("@magek/common");
+const event_registry_1 = require("../event-registry");
+const originOfTime = new Date(0).toISOString();
+function rawEventsToEnvelopes(rawEvents) {
+    return rawEvents.map((event) => event);
+}
+async function readEntityEventsSince(eventRegistry, config, entityTypeName, entityID, since) {
+    const logger = (0, common_1.getLogger)(config, 'events-adapter#readEntityEventsSince');
+    const fromTime = since ? since : originOfTime;
+    const query = {
+        entityID: entityID,
+        entityTypeName: entityTypeName,
+        kind: 'event',
+        createdAt: {
+            $gt: fromTime,
+        },
+        deletedAt: { $exists: false },
+    };
+    const result = await eventRegistry.query(query);
+    logger.debug(`Loaded events for entity ${entityTypeName} with ID ${entityID} with result:`, result);
+    return result;
+}
+async function readEntityLatestSnapshot(eventRegistry, config, entityTypeName, entityID) {
+    const logger = (0, common_1.getLogger)(config, 'events-adapter#readEntityLatestSnapshot');
+    const query = {
+        entityID: entityID,
+        entityTypeName: entityTypeName,
+        kind: 'snapshot',
+    };
+    const snapshot = await eventRegistry.queryLatestSnapshot(query);
+    if (snapshot) {
+        logger.debug(`Snapshot found for entity ${entityTypeName} with ID ${entityID}:`, snapshot);
+        return snapshot;
+    }
+    else {
+        logger.debug(`No snapshot found for entity ${entityTypeName} with ID ${entityID}.`);
+        return undefined;
+    }
+}
+async function storeEvents(userApp, 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(),
+        };
+        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) {
+    const logger = (0, common_1.getLogger)(config, 'events-adapter#storeSnapshot');
+    logger.debug('Storing the following snapshot envelope:', snapshotEnvelope);
+    const persistableEntitySnapshot = {
+        ...snapshotEnvelope,
+        createdAt: snapshotEnvelope.snapshottedEventCreatedAt,
+        persistedAt: new Date().toISOString(),
+    };
+    await (0, common_1.retryIfError)(() => eventRegistry.store(persistableEntitySnapshot), common_1.OptimisticConcurrencyUnexpectedVersionError);
+    logger.debug('Snapshot stored');
+    return persistableEntitySnapshot;
+}
+/**
+ * Dummy method that'll always return true, since local provider won't be tracking dispatched events
+ */
+async function storeDispatchedEvent() {
+    return true;
+}
+async function persistEvent(eventRegistry, eventEnvelope) {
+    await eventRegistry.store(eventEnvelope);
+}
+async function getDatabaseEventsHealthDetails(eventRegistry) {
+    const count = await eventRegistry.count();
+    return {
+        file: event_registry_1.eventsDatabase,
+        count: count,
+    };
+}

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

@@ -0,0 +1,4 @@
+import { MagekConfig, EventSearchParameters, EventSearchResponse, PaginatedEntitiesIdsResult } from '@magek/common';
+import { EventRegistry } from '../event-registry';
+export declare function searchEvents(eventRegistry: EventRegistry, config: MagekConfig, parameters: EventSearchParameters): Promise<Array<EventSearchResponse>>;
+export declare function searchEntitiesIds(eventRegistry: EventRegistry, config: MagekConfig, limit: number, afterCursor: Record<string, string> | undefined, entityTypeName: string): Promise<PaginatedEntitiesIdsResult>;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchEvents = searchEvents;
+exports.searchEntitiesIds = searchEntitiesIds;
+const common_1 = require("@magek/common");
+const events_searcher_builder_1 = require("./events-searcher-builder");
+const DEFAULT_CREATED_AT_SORT_ORDER = -1;
+const DEFAULT_KIND_FILTER = { kind: 'event' };
+async function searchEvents(eventRegistry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'events-searcher-adapter#searchEvents');
+    logger.debug('Initiating an events search. Filters: ', parameters);
+    const timeFilterQuery = (0, events_searcher_builder_1.buildFiltersForByTime)(parameters.from, parameters.to);
+    const eventFilterQuery = (0, events_searcher_builder_1.buildFiltersForByFilters)(parameters);
+    const filterQuery = { ...eventFilterQuery, ...timeFilterQuery, ...DEFAULT_KIND_FILTER };
+    const result = (await eventRegistry.query(filterQuery, DEFAULT_CREATED_AT_SORT_ORDER, parameters.limit));
+    const eventsSearchResponses = (0, events_searcher_builder_1.resultToEventSearchResponse)(result);
+    logger.debug('Events search result: ', eventsSearchResponses);
+    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 = {
+        ...DEFAULT_KIND_FILTER,
+        entityTypeName: entityTypeName,
+        deletedAt: { $exists: false },
+    };
+    const result = (await eventRegistry.query(filterQuery, DEFAULT_CREATED_AT_SORT_ORDER, undefined, {
+        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 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 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,
+        cursor: { id: ((limit ? limit : 1) + skipId).toString() },
+    };
+}

package/dist/library/events-searcher-builder.d.ts

@@ -0,0 +1,11 @@
+import { EventEnvelope, EventParametersFilterByEntity, EventParametersFilterByType, EventSearchResponse, UUID } from '@magek/common';
+interface QueryFields {
+    createdAt?: unknown;
+    entityTypeName?: string;
+    entityID?: UUID;
+    typeName?: string;
+}
+export declare function buildFiltersForByTime(fromValue?: string, toValue?: string): QueryFields;
+export declare function buildFiltersForByFilters(filters: EventParametersFilterByEntity | EventParametersFilterByType): QueryFields;
+export declare function resultToEventSearchResponse(result: Array<EventEnvelope> | null): Array<EventSearchResponse>;
+export {};

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFiltersForByTime = buildFiltersForByTime;
+exports.buildFiltersForByFilters = buildFiltersForByFilters;
+exports.resultToEventSearchResponse = resultToEventSearchResponse;
+function buildFiltersForByTime(fromValue, toValue) {
+    if (fromValue && toValue) {
+        return {
+            createdAt: { $gte: fromValue, $lte: toValue },
+        };
+    }
+    else if (fromValue) {
+        return {
+            createdAt: { $gte: fromValue },
+        };
+    }
+    else if (toValue) {
+        return {
+            createdAt: { $lte: toValue },
+        };
+    }
+    return {};
+}
+function buildFiltersForByFilters(filters) {
+    if ('entity' in filters) {
+        if (filters.entityID) {
+            return buildByEntityAndID(filters.entity, filters.entityID);
+        }
+        return buildByEntity(filters.entity);
+    }
+    else if ('type' in filters) {
+        return buildByType(filters.type);
+    }
+    else {
+        throw new Error('Invalid search event query. It is neither an search by "entity" nor a search by "type"');
+    }
+}
+function resultToEventSearchResponse(result) {
+    if (!result || result.length === 0)
+        return [];
+    const eventSearchResult = result.map((item) => {
+        return {
+            type: item.typeName,
+            entity: item.entityTypeName,
+            entityID: item.entityID,
+            requestID: item.requestID,
+            user: item.currentUser,
+            createdAt: item.createdAt,
+            value: item.value,
+            deletedAt: item.deletedAt,
+        };
+    });
+    return eventSearchResult !== null && eventSearchResult !== void 0 ? eventSearchResult : [];
+}
+function buildByEntityAndID(entityValue, entityIdValue) {
+    return {
+        entityTypeName: entityValue,
+        entityID: entityIdValue,
+    };
+}
+function buildByEntity(entityValue) {
+    return {
+        entityTypeName: entityValue,
+    };
+}
+function buildByType(typeValue) {
+    return {
+        typeName: typeValue,
+    };
+}

package/dist/paths.d.ts

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

package/dist/paths.js

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

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@magek/adapter-event-store-nedb",
+  "version": "0.0.1",
+  "description": "Nedb-based event store adapter for the Magek framework",
+  "keywords": [
+    "event-store",
+    "nedb"
+  ],
+  "author": "Boosterin Labs SLU",
+  "homepage": "https://magek.ai",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theam/magek.git"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0"
+  },
+  "dependencies": {
+    "@magek/common": "^0.0.1",
+    "@seald-io/nedb": "4.1.2",
+    "tslib": "2.8.1"
+  },
+  "bugs": {
+    "url": "https://github.com/theam/magek/issues"
+  },
+  "devDependencies": {
+    "@magek/eslint-config": "^0.0.1",
+    "@types/chai": "5.2.3",
+    "@types/chai-as-promised": "8.0.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "22.19.3",
+    "@types/sinon": "21.0.0",
+    "@types/sinon-chai": "4.0.0",
+    "chai": "6.2.2",
+    "chai-as-promised": "8.0.2",
+    "@faker-js/faker": "10.2.0",
+    "mocha": "11.7.5",
+    "c8": "^10.1.3",
+    "rimraf": "6.1.2",
+    "sinon": "21.0.1",
+    "sinon-chai": "4.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "format": "prettier --write --ext '.js,.ts' **/*.ts **/*/*.ts",
+    "lint:check": "eslint \"**/*.ts\"",
+    "lint:fix": "eslint --quiet --fix \"**/*.ts\"",
+    "build": "tsc -b tsconfig.json",
+    "clean": "rimraf ./dist tsconfig.tsbuildinfo",
+    "test": "tsc --noEmit -p tsconfig.test.json && c8 mocha --forbid-only \"test/**/*.test.ts\""
+  }
+}