@magek/adapter-event-store-memory 0.0.10

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { EventStoreAdapter, EventEnvelope } from '@magek/common';
+export declare function rawEventsToEnvelopes(rawEvents: Array<unknown>): Array<EventEnvelope>;
+export declare const eventStore: EventStoreAdapter;
+export { MemoryEventRegistry } from './memory-event-registry';

package/dist/index.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryEventRegistry = exports.eventStore = void 0;
+exports.rawEventsToEnvelopes = rawEventsToEnvelopes;
+const common_1 = require("@magek/common");
+const memory_event_registry_1 = require("./memory-event-registry");
+// Pre-built Memory Event Store Adapter instance
+const eventRegistry = new memory_event_registry_1.MemoryEventRegistry();
+const originOfTime = new Date(0).toISOString();
+// In-memory cursor for async event processing
+let processingCursor = originOfTime;
+function notImplemented() {
+    throw new Error('Not implemented for Memory adapter');
+}
+function rawEventsToEnvelopes(rawEvents) {
+    return rawEvents.map((event) => event);
+}
+async function readEntityEventsSince(registry, config, entityTypeName, entityID, since) {
+    const logger = (0, common_1.getLogger)(config, 'memory-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 registry.query(query);
+    logger.debug(`Loaded events for entity ${entityTypeName} with ID ${entityID} with result:`, result);
+    return result;
+}
+async function readEntityLatestSnapshot(registry, config, entityTypeName, entityID) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#readEntityLatestSnapshot');
+    const query = {
+        entityID: entityID,
+        entityTypeName: entityTypeName,
+        kind: 'snapshot',
+    };
+    const snapshot = await registry.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(registry, nonPersistedEventEnvelopes, config) {
+    const logger = (0, common_1.getLogger)(config, 'memory-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 registry.store(persistableEventEnvelope), common_1.OptimisticConcurrencyUnexpectedVersionError);
+        persistedEventEnvelopes.push(persistableEventEnvelope);
+    }
+    logger.debug('EventEnvelopes stored: ', persistedEventEnvelopes);
+    return persistedEventEnvelopes;
+}
+async function storeSnapshot(registry, snapshotEnvelope, config) {
+    const logger = (0, common_1.getLogger)(config, 'memory-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)(() => registry.store(persistableEntitySnapshot), common_1.OptimisticConcurrencyUnexpectedVersionError);
+    logger.debug('Snapshot stored');
+    return persistableEntitySnapshot;
+}
+async function storeDispatchedEvent(registry, eventEnvelope) {
+    const eventId = eventEnvelope.id || `${eventEnvelope.entityTypeName}:${eventEnvelope.entityID}:${eventEnvelope.createdAt}`;
+    return registry.storeDispatched(eventId);
+}
+async function fetchUnprocessedEvents(registry, config) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#fetchUnprocessedEvents');
+    const batchSize = config.eventProcessingBatchSize;
+    const query = {
+        kind: 'event',
+        deletedAt: { $exists: false },
+        processedAt: { $exists: false },
+        createdAt: { $gt: processingCursor },
+    };
+    logger.debug(`Fetching events after cursor ${processingCursor} (batch size: ${batchSize})`);
+    const result = await registry.query(query, 'asc', batchSize);
+    logger.debug(`Fetched ${result.length} unprocessed events`);
+    return result;
+}
+async function markEventProcessed(registry, config, eventId) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#markEventProcessed');
+    const processedAt = new Date().toISOString();
+    const events = await registry.query({ _id: eventId.toString(), kind: 'event' });
+    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 registry.markProcessed(eventId.toString(), processedAt);
+    processingCursor = event.createdAt;
+    logger.debug(`Cursor advanced to ${processingCursor}`);
+}
+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 {
+                entityTypeName: filters.entity,
+                entityID: filters.entityID,
+            };
+        }
+        return {
+            entityTypeName: filters.entity,
+        };
+    }
+    else if ('type' in filters) {
+        return {
+            typeName: 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 ?? [];
+}
+async function searchEvents(registry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#searchEvents');
+    logger.debug('Initiating an events search. Filters: ', parameters);
+    const timeFilterQuery = buildFiltersForByTime(parameters.from, parameters.to);
+    const eventFilterQuery = buildFiltersForByFilters(parameters);
+    const filterQuery = { ...eventFilterQuery, ...timeFilterQuery, kind: 'event' };
+    const result = (await registry.query(filterQuery, 'desc', parameters.limit));
+    const eventsSearchResponses = resultToEventSearchResponse(result);
+    logger.debug('Events search result: ', eventsSearchResponses);
+    return eventsSearchResponses;
+}
+async function searchEntitiesIds(registry, config, limit, afterCursor, entityTypeName) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#searchEntitiesIds');
+    logger.debug(`Initiating a paginated events search. limit: ${limit}, afterCursor: ${JSON.stringify(afterCursor)}, entityTypeName: ${entityTypeName}`);
+    const filterQuery = {
+        kind: 'event',
+        entityTypeName: entityTypeName,
+        deletedAt: { $exists: false },
+    };
+    const result = (await registry.query(filterQuery, 'desc'));
+    const entitiesIds = result ? result?.map((v) => v.entityID) : [];
+    const uniqueResult = (0, common_1.unique)(entitiesIds);
+    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: paginatedResult?.length ?? 0,
+        cursor: { id: ((limit ? limit : 1) + skipId).toString() },
+    };
+}
+async function findDeletableEvent(registry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#findDeletableEvent');
+    const stringifyParameters = JSON.stringify(parameters);
+    logger.debug(`Initiating a deletable event search for ${stringifyParameters}`);
+    const filter = {
+        entityTypeName: parameters.entityTypeName,
+        entityID: parameters.entityID,
+        createdAt: parameters.createdAt,
+        kind: 'event',
+        deletedAt: { $exists: false },
+    };
+    const events = (await registry.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(registry, config, parameters) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-adapter#findDeletableSnapshot');
+    const stringifyParameters = JSON.stringify(parameters);
+    logger.debug(`Initiating a deletable snapshot search for ${stringifyParameters}`);
+    const filter = {
+        entityTypeName: parameters.entityTypeName,
+        entityID: parameters.entityID,
+        createdAt: parameters.createdAt,
+        kind: 'snapshot',
+        deletedAt: { $exists: false },
+    };
+    const snapshots = (await registry.query(filter));
+    const result = snapshots.map((snapshot) => {
+        return {
+            ...snapshot,
+            id: snapshot.id,
+        };
+    });
+    logger.debug(`Finished deletable snapshot search for ${stringifyParameters}`);
+    return result;
+}
+function buildNewEvent(existingEvent) {
+    return {
+        ...existingEvent,
+        deletedAt: new Date().toISOString(),
+        value: {},
+    };
+}
+async function deleteEvent(registry, config, events) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-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 registry.replaceOrDeleteItem(event.id, newEvent);
+    }
+    logger.debug(`Finished event delete for ${stringifyParameters}`);
+}
+async function deleteSnapshot(registry, config, snapshots) {
+    const logger = (0, common_1.getLogger)(config, 'memory-events-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 registry.replaceOrDeleteItem(snapshot.id);
+    }
+    logger.debug(`Finished snapshot delete for ${stringifyParameters}`);
+}
+exports.eventStore = {
+    rawToEnvelopes: rawEventsToEnvelopes,
+    rawStreamToEnvelopes: notImplemented,
+    dedupEventStream: notImplemented,
+    produce: notImplemented,
+    forEntitySince: (config, entityTypeName, entityID, since) => readEntityEventsSince(eventRegistry, config, entityTypeName, entityID, since),
+    latestEntitySnapshot: (config, entityTypeName, entityID) => readEntityLatestSnapshot(eventRegistry, config, entityTypeName, entityID),
+    store: (eventEnvelopes, config) => storeEvents(eventRegistry, eventEnvelopes, config),
+    storeSnapshot: (snapshotEnvelope, config) => storeSnapshot(eventRegistry, snapshotEnvelope, config),
+    search: (config, parameters) => searchEvents(eventRegistry, config, parameters),
+    searchEntitiesIDs: (config, limit, afterCursor, entityTypeName) => searchEntitiesIds(eventRegistry, config, limit, afterCursor, entityTypeName),
+    storeDispatched: (eventEnvelope, config) => storeDispatchedEvent(eventRegistry, eventEnvelope),
+    findDeletableEvent: (config, parameters) => findDeletableEvent(eventRegistry, config, parameters),
+    findDeletableSnapshot: (config, parameters) => findDeletableSnapshot(eventRegistry, config, parameters),
+    deleteEvent: (config, events) => deleteEvent(eventRegistry, config, events),
+    deleteSnapshot: (config, snapshots) => deleteSnapshot(eventRegistry, config, snapshots),
+    healthCheck: {
+        isUp: async () => true,
+        details: async () => {
+            return {
+                type: 'memory',
+                eventsCount: eventRegistry.getEventsCount(),
+                snapshotsCount: eventRegistry.getSnapshotsCount(),
+            };
+        },
+        urls: async () => ['memory://in-memory-event-store'],
+    },
+    fetchUnprocessedEvents: (config) => fetchUnprocessedEvents(eventRegistry, config),
+    markEventProcessed: (config, eventId) => markEventProcessed(eventRegistry, config, eventId),
+};
+// Export components for testing
+var memory_event_registry_2 = require("./memory-event-registry");
+Object.defineProperty(exports, "MemoryEventRegistry", { enumerable: true, get: function () { return memory_event_registry_2.MemoryEventRegistry; } });

package/dist/memory-event-registry.d.ts

@@ -0,0 +1,45 @@
+import { EntitySnapshotEnvelope, EventEnvelope, UUID } from '@magek/common';
+export declare class MemoryEventRegistry {
+    private events;
+    private snapshots;
+    private dispatched;
+    private eventsByEntity;
+    private snapshotsByEntity;
+    private eventIdCounter;
+    private snapshotIdCounter;
+    private generateEventId;
+    private generateSnapshotId;
+    private getEntityKey;
+    query(query: QueryFilter, sortOrder?: 'asc' | 'desc', limit?: number): Promise<Array<EventEnvelope | EntitySnapshotEnvelope>>;
+    queryLatestSnapshot(query: QueryFilter): Promise<EntitySnapshotEnvelope | undefined>;
+    store(envelope: EventEnvelope | EntitySnapshotEnvelope): Promise<string>;
+    storeDispatched(eventId: string): Promise<boolean>;
+    replaceOrDeleteItem(id: string, newValue?: EventEnvelope | EntitySnapshotEnvelope): Promise<void>;
+    deleteAll(): Promise<number>;
+    count(query?: QueryFilter): Promise<number>;
+    getEventsCount(): number;
+    getSnapshotsCount(): number;
+    private matchesFilter;
+    markProcessed(id: string, processedAt: string): Promise<void>;
+}
+interface CreatedAtConditions {
+    $gt?: string;
+    $gte?: string;
+    $lt?: string;
+    $lte?: string;
+}
+export interface QueryFilter {
+    kind?: 'event' | 'snapshot';
+    entityTypeName?: string;
+    entityID?: UUID;
+    typeName?: string;
+    createdAt?: string | CreatedAtConditions;
+    deletedAt?: {
+        $exists: boolean;
+    };
+    processedAt?: {
+        $exists: boolean;
+    };
+    _id?: string;
+}
+export {};

package/dist/memory-event-registry.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryEventRegistry = void 0;
+class MemoryEventRegistry {
+    events = new Map();
+    snapshots = new Map();
+    dispatched = new Set();
+    eventsByEntity = new Map();
+    snapshotsByEntity = new Map();
+    eventIdCounter = 0;
+    snapshotIdCounter = 0;
+    generateEventId() {
+        return `evt-${++this.eventIdCounter}-${Date.now()}`;
+    }
+    generateSnapshotId() {
+        return `snap-${++this.snapshotIdCounter}-${Date.now()}`;
+    }
+    getEntityKey(entityTypeName, entityID) {
+        return `${entityTypeName}:${entityID}`;
+    }
+    async query(query, sortOrder = 'asc', limit) {
+        const results = [];
+        // Query events
+        if (!query.kind || query.kind === 'event') {
+            for (const event of Array.from(this.events.values())) {
+                if (this.matchesFilter(event, query)) {
+                    results.push(event);
+                }
+            }
+        }
+        // Query snapshots
+        if (query.kind === 'snapshot') {
+            for (const snapshot of Array.from(this.snapshots.values())) {
+                if (this.matchesFilter(snapshot, query)) {
+                    results.push(snapshot);
+                }
+            }
+        }
+        // Sort by createdAt
+        results.sort((a, b) => {
+            const aTime = new Date(a.createdAt ?? 0).getTime();
+            const bTime = new Date(b.createdAt ?? 0).getTime();
+            return sortOrder === 'asc' ? aTime - bTime : bTime - aTime;
+        });
+        // Apply limit
+        if (limit && limit > 0) {
+            return results.slice(0, limit);
+        }
+        return results;
+    }
+    async queryLatestSnapshot(query) {
+        const matchingSnapshots = [];
+        for (const snapshot of Array.from(this.snapshots.values())) {
+            if (this.matchesFilter(snapshot, { ...query, kind: 'snapshot' })) {
+                matchingSnapshots.push(snapshot);
+            }
+        }
+        if (matchingSnapshots.length === 0) {
+            return undefined;
+        }
+        // Sort by snapshottedEventCreatedAt descending and return the first one
+        matchingSnapshots.sort((a, b) => {
+            const aTime = new Date(a.snapshottedEventCreatedAt).getTime();
+            const bTime = new Date(b.snapshottedEventCreatedAt).getTime();
+            return bTime - aTime;
+        });
+        return matchingSnapshots[0];
+    }
+    async store(envelope) {
+        if (envelope.kind === 'event') {
+            const eventEnvelope = envelope;
+            const id = this.generateEventId();
+            const storedEnvelope = { ...eventEnvelope, id };
+            this.events.set(id, storedEnvelope);
+            // Index by entity
+            const entityKey = this.getEntityKey(eventEnvelope.entityTypeName, eventEnvelope.entityID);
+            if (!this.eventsByEntity.has(entityKey)) {
+                this.eventsByEntity.set(entityKey, new Set());
+            }
+            this.eventsByEntity.get(entityKey).add(id);
+            return id;
+        }
+        else {
+            const snapshotEnvelope = envelope;
+            const id = this.generateSnapshotId();
+            const storedEnvelope = { ...snapshotEnvelope, id };
+            this.snapshots.set(id, storedEnvelope);
+            // Index by entity
+            const entityKey = this.getEntityKey(snapshotEnvelope.entityTypeName, snapshotEnvelope.entityID);
+            if (!this.snapshotsByEntity.has(entityKey)) {
+                this.snapshotsByEntity.set(entityKey, new Set());
+            }
+            this.snapshotsByEntity.get(entityKey).add(id);
+            return id;
+        }
+    }
+    async storeDispatched(eventId) {
+        if (this.dispatched.has(eventId)) {
+            return false;
+        }
+        this.dispatched.add(eventId);
+        return true;
+    }
+    async replaceOrDeleteItem(id, newValue) {
+        // Check in events
+        if (this.events.has(id)) {
+            if (newValue) {
+                this.events.set(id, newValue);
+            }
+            else {
+                const event = this.events.get(id);
+                const entityKey = this.getEntityKey(event.entityTypeName, event.entityID);
+                this.eventsByEntity.get(entityKey)?.delete(id);
+                this.events.delete(id);
+            }
+            return;
+        }
+        // Check in snapshots
+        if (this.snapshots.has(id)) {
+            if (newValue) {
+                this.snapshots.set(id, newValue);
+            }
+            else {
+                const snapshot = this.snapshots.get(id);
+                const entityKey = this.getEntityKey(snapshot.entityTypeName, snapshot.entityID);
+                this.snapshotsByEntity.get(entityKey)?.delete(id);
+                this.snapshots.delete(id);
+            }
+        }
+    }
+    async deleteAll() {
+        const count = this.events.size + this.snapshots.size;
+        this.events.clear();
+        this.snapshots.clear();
+        this.dispatched.clear();
+        this.eventsByEntity.clear();
+        this.snapshotsByEntity.clear();
+        return count;
+    }
+    async count(query) {
+        if (!query) {
+            return this.events.size + this.snapshots.size;
+        }
+        let count = 0;
+        if (!query.kind || query.kind === 'event') {
+            for (const event of Array.from(this.events.values())) {
+                if (this.matchesFilter(event, query)) {
+                    count++;
+                }
+            }
+        }
+        if (query.kind === 'snapshot') {
+            for (const snapshot of Array.from(this.snapshots.values())) {
+                if (this.matchesFilter(snapshot, query)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    getEventsCount() {
+        return this.events.size;
+    }
+    getSnapshotsCount() {
+        return this.snapshots.size;
+    }
+    matchesFilter(envelope, query) {
+        // Check _id
+        if (query._id && envelope.id !== query._id) {
+            return false;
+        }
+        // Check kind
+        if (query.kind && envelope.kind !== query.kind) {
+            return false;
+        }
+        // Check entityTypeName
+        if (query.entityTypeName && envelope.entityTypeName !== query.entityTypeName) {
+            return false;
+        }
+        // Check entityID
+        if (query.entityID && envelope.entityID !== query.entityID) {
+            return false;
+        }
+        // Check typeName
+        if (query.typeName && envelope.typeName !== query.typeName) {
+            return false;
+        }
+        // Check createdAt conditions
+        const envelopeCreatedAt = envelope.createdAt;
+        if (query.createdAt && envelopeCreatedAt) {
+            if (typeof query.createdAt === 'object') {
+                const conditions = query.createdAt;
+                const envelopeTime = new Date(envelopeCreatedAt).getTime();
+                if (conditions.$gt) {
+                    const gtTime = new Date(conditions.$gt).getTime();
+                    if (envelopeTime <= gtTime)
+                        return false;
+                }
+                if (conditions.$gte) {
+                    const gteTime = new Date(conditions.$gte).getTime();
+                    if (envelopeTime < gteTime)
+                        return false;
+                }
+                if (conditions.$lt) {
+                    const ltTime = new Date(conditions.$lt).getTime();
+                    if (envelopeTime >= ltTime)
+                        return false;
+                }
+                if (conditions.$lte) {
+                    const lteTime = new Date(conditions.$lte).getTime();
+                    if (envelopeTime > lteTime)
+                        return false;
+                }
+            }
+            else if (envelopeCreatedAt !== query.createdAt) {
+                return false;
+            }
+        }
+        // Check deletedAt exists condition
+        if (query.deletedAt !== undefined) {
+            if (typeof query.deletedAt === 'object' && '$exists' in query.deletedAt) {
+                const hasDeletedAt = envelope.deletedAt !== undefined;
+                if (query.deletedAt.$exists !== hasDeletedAt)
+                    return false;
+            }
+        }
+        // Check processedAt exists condition
+        if (query.processedAt !== undefined) {
+            if (typeof query.processedAt === 'object' && '$exists' in query.processedAt) {
+                const hasProcessedAt = envelope.processedAt !== undefined;
+                if (query.processedAt.$exists !== hasProcessedAt)
+                    return false;
+            }
+        }
+        return true;
+    }
+    async markProcessed(id, processedAt) {
+        const event = this.events.get(id);
+        if (event) {
+            this.events.set(id, { ...event, processedAt });
+        }
+    }
+}
+exports.MemoryEventRegistry = MemoryEventRegistry;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@magek/adapter-event-store-memory",
+  "version": "0.0.10",
+  "description": "In-memory event store adapter for the Magek framework",
+  "keywords": [
+    "event-store",
+    "memory",
+    "in-memory"
+  ],
+  "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": "workspace:^0.0.10",
+    "tslib": "2.8.1"
+  },
+  "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",
+    "prepack": "tsc -b tsconfig.json",
+    "test": "tsc --noEmit -p tsconfig.test.json && c8 mocha --forbid-only \"test/**/*.test.ts\""
+  },
+  "bugs": {
+    "url": "https://github.com/theam/magek/issues"
+  },
+  "devDependencies": {
+    "@magek/eslint-config": "workspace:^0.0.10",
+    "@types/chai": "5.2.3",
+    "@types/chai-as-promised": "8.0.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "22.19.8",
+    "@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"
+  }
+}