@magek/adapter-read-model-store-memory 0.0.10

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { MagekConfig, ReadModelInterface, ReadModelStoreAdapter, UUID, FilterFor, SortFor, ProjectionFor, ReadModelListResult, SequenceKey, ReadOnlyNonEmptyArray } from '@magek/common';
+import { MemoryReadModelRegistry } from './memory-read-model-registry';
+declare function fetchReadModel(db: MemoryReadModelRegistry, config: MagekConfig, readModelName: string, readModelID: UUID, sequenceKey?: SequenceKey): Promise<ReadOnlyNonEmptyArray<ReadModelInterface> | undefined>;
+declare function storeReadModel(db: MemoryReadModelRegistry, config: MagekConfig, readModelName: string, readModel: ReadModelInterface, expectedCurrentVersion: number): Promise<void>;
+declare function searchReadModel<TReadModel extends ReadModelInterface>(db: MemoryReadModelRegistry, config: MagekConfig, readModelName: string, filters: FilterFor<unknown>, sortBy?: SortFor<unknown>, limit?: number, afterCursor?: Record<string, string> | undefined, paginatedVersion?: boolean, select?: ProjectionFor<TReadModel>): Promise<Array<TReadModel> | ReadModelListResult<TReadModel>>;
+declare function deleteReadModel(db: MemoryReadModelRegistry, config: MagekConfig, readModelName: string, readModel: ReadModelInterface): Promise<void>;
+export declare const readModelStore: ReadModelStoreAdapter;
+export { MemoryReadModelRegistry } from './memory-read-model-registry';
+export { evaluateFilter, convertFilter } from './library/filter-evaluator';
+export { fetchReadModel, storeReadModel, searchReadModel, deleteReadModel };

package/dist/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFilter = exports.evaluateFilter = exports.MemoryReadModelRegistry = exports.readModelStore = void 0;
+exports.fetchReadModel = fetchReadModel;
+exports.storeReadModel = storeReadModel;
+exports.searchReadModel = searchReadModel;
+exports.deleteReadModel = deleteReadModel;
+const common_1 = require("@magek/common");
+const memory_read_model_registry_1 = require("./memory-read-model-registry");
+// Pre-built Memory Read Model Store Adapter instance
+const readModelRegistry = new memory_read_model_registry_1.MemoryReadModelRegistry();
+async function fetchReadModel(db, config, readModelName, readModelID, sequenceKey) {
+    const logger = (0, common_1.getLogger)(config, 'memory-read-model-adapter#fetchReadModel');
+    const query = { typeName: readModelName, 'value.id': readModelID };
+    // If sequenceKey is provided, add it to the query
+    if (sequenceKey) {
+        query[`value.${sequenceKey.name}`] = sequenceKey.value;
+    }
+    const response = await db.query(query);
+    if (response.length === 0) {
+        logger.debug(`Read model ${readModelName} with ID ${readModelID} not found`);
+        return undefined;
+    }
+    logger.debug(`Loaded read model ${readModelName} with ID ${readModelID} with result:`, response.map((item) => item.value));
+    return response.map((item) => item.value);
+}
+async function storeReadModel(db, config, readModelName, readModel, expectedCurrentVersion) {
+    const logger = (0, common_1.getLogger)(config, 'memory-read-model-adapter#storeReadModel');
+    logger.debug('Storing readModel ' + JSON.stringify(readModel));
+    try {
+        await db.store({ typeName: readModelName, value: readModel }, expectedCurrentVersion);
+    }
+    catch (e) {
+        if (e instanceof common_1.OptimisticConcurrencyUnexpectedVersionError) {
+            logger.warn(`Unique violated storing ReadModel ${JSON.stringify(readModel)} and expectedCurrentVersion ${expectedCurrentVersion}`);
+            throw e;
+        }
+        throw e;
+    }
+    logger.debug('Read model stored');
+}
+async function searchReadModel(db, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion = false, select) {
+    const logger = (0, common_1.getLogger)(config, 'memory-read-model-adapter#searchReadModel');
+    logger.debug('Converting filter to query');
+    const query = { typeName: readModelName, filters };
+    logger.debug('Got query ', query);
+    const skipId = afterCursor?.id ? parseInt(afterCursor?.id) : 0;
+    const result = await db.query(query, sortBy, skipId, limit, select);
+    logger.debug('Search result: ', result);
+    const items = result?.map((envelope) => envelope.value) ?? [];
+    if (paginatedVersion) {
+        return {
+            items: items,
+            count: items?.length ?? 0,
+            cursor: { id: ((limit ? limit : 1) + skipId).toString() },
+        };
+    }
+    return items;
+}
+async function deleteReadModel(db, config, readModelName, readModel) {
+    const logger = (0, common_1.getLogger)(config, 'memory-read-model-adapter#deleteReadModel');
+    logger.debug(`Entering to Read model deleted. ID=${readModel.id}.Name=${readModelName}`);
+    try {
+        await db.deleteById(readModel.id, readModelName);
+        logger.debug(`Read model deleted. ${readModelName} ID = ${readModel.id}`);
+    }
+    catch (e) {
+        logger.warn(`Read model to delete ${readModelName} ID = ${readModel.id} not found`);
+    }
+}
+exports.readModelStore = {
+    fetch: async (config, readModelName, readModelID, sequenceKey) => {
+        const result = await fetchReadModel(readModelRegistry, config, readModelName, readModelID, sequenceKey);
+        if (!result || result.length === 0) {
+            return undefined;
+        }
+        return result;
+    },
+    search: async (config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion, select) => {
+        return await searchReadModel(readModelRegistry, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion ?? false, select);
+    },
+    store: async (config, readModelName, readModel) => {
+        const expectedCurrentVersion = (readModel.version ?? 1) - 1;
+        await storeReadModel(readModelRegistry, config, readModelName, readModel.value, expectedCurrentVersion);
+        // Return the stored envelope with updated timestamps
+        return {
+            ...readModel,
+            updatedAt: new Date().toISOString(),
+        };
+    },
+    delete: async (config, readModelName, readModelID) => {
+        // Create a minimal ReadModelInterface for the delete operation
+        const readModel = {
+            id: readModelID,
+        };
+        await deleteReadModel(readModelRegistry, config, readModelName, readModel);
+    },
+    rawToEnvelopes: async (config, rawReadModels) => {
+        // This would typically convert raw database records to envelopes
+        // For now, assume rawReadModels is already in the correct format
+        return rawReadModels;
+    },
+    healthCheck: {
+        isUp: async () => true,
+        details: async () => {
+            return {
+                type: 'memory',
+                count: readModelRegistry.getCount(),
+            };
+        },
+        urls: async () => ['memory://in-memory-read-model-store'],
+    },
+};
+// Export individual components for backward compatibility and testing
+var memory_read_model_registry_2 = require("./memory-read-model-registry");
+Object.defineProperty(exports, "MemoryReadModelRegistry", { enumerable: true, get: function () { return memory_read_model_registry_2.MemoryReadModelRegistry; } });
+var filter_evaluator_1 = require("./library/filter-evaluator");
+Object.defineProperty(exports, "evaluateFilter", { enumerable: true, get: function () { return filter_evaluator_1.evaluateFilter; } });
+Object.defineProperty(exports, "convertFilter", { enumerable: true, get: function () { return filter_evaluator_1.convertFilter; } });

package/dist/library/filter-evaluator.d.ts

@@ -0,0 +1,42 @@
+export type FilterValue = number | string | boolean | null | undefined;
+export interface EvaluatedFilter {
+    [key: string]: FilterOperation;
+}
+export type FilterOperation = FilterValue | {
+    $eq?: FilterValue;
+} | {
+    $ne?: FilterValue;
+} | {
+    $lt?: FilterValue;
+} | {
+    $gt?: FilterValue;
+} | {
+    $lte?: FilterValue;
+} | {
+    $gte?: FilterValue;
+} | {
+    $in?: FilterValue[];
+} | {
+    $exists?: boolean;
+} | {
+    $regex?: RegExp;
+} | {
+    $elemMatch?: FilterValue;
+} | {
+    $and?: EvaluatedFilter[];
+} | {
+    $or?: EvaluatedFilter[];
+} | {
+    $not?: EvaluatedFilter;
+};
+/**
+ * Evaluates a filter against a value object.
+ * Returns true if the value matches the filter conditions.
+ */
+export declare function evaluateFilter(value: Record<string, any>, filters: any): boolean;
+/**
+ * Converts a GraphQL filter to an evaluated filter structure.
+ * This function transforms Magek-style filters into a format that can be
+ * efficiently evaluated against data.
+ */
+export declare function convertFilter(filters: any, prefix?: string): EvaluatedFilter;

package/dist/library/filter-evaluator.js

@@ -0,0 +1,238 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateFilter = evaluateFilter;
+exports.convertFilter = convertFilter;
+/**
+ * Evaluates a filter against a value object.
+ * Returns true if the value matches the filter conditions.
+ */
+function evaluateFilter(value, filters) {
+    if (!filters || Object.keys(filters).length === 0) {
+        return true;
+    }
+    for (const key in filters) {
+        const filterValue = filters[key];
+        // Handle logical operators
+        if (key === 'and') {
+            const andFilters = filterValue;
+            if (!andFilters.every((f) => evaluateFilter(value, f))) {
+                return false;
+            }
+            continue;
+        }
+        if (key === 'or') {
+            const orFilters = filterValue;
+            if (!orFilters.some((f) => evaluateFilter(value, f))) {
+                return false;
+            }
+            continue;
+        }
+        if (key === 'not') {
+            if (evaluateFilter(value, filterValue)) {
+                return false;
+            }
+            continue;
+        }
+        // Handle field-level filters
+        const fieldValue = getNestedValue(value, key);
+        if (!evaluateFieldFilter(fieldValue, filterValue)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Gets a nested value from an object using dot notation.
+ */
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Evaluates a filter against a single field value.
+ */
+function evaluateFieldFilter(fieldValue, filter) {
+    if (filter === null || filter === undefined) {
+        return true;
+    }
+    // If filter is a primitive, it's an implicit eq operation
+    if (typeof filter !== 'object') {
+        return fieldValue === filter;
+    }
+    // Check for filter operations
+    const filterKeys = Object.keys(filter);
+    for (const op of filterKeys) {
+        const opValue = filter[op];
+        switch (op) {
+            case 'eq':
+                if (fieldValue !== opValue)
+                    return false;
+                break;
+            case 'ne':
+                if (fieldValue === opValue)
+                    return false;
+                break;
+            case 'lt':
+                if (fieldValue >= opValue)
+                    return false;
+                break;
+            case 'gt':
+                if (fieldValue <= opValue)
+                    return false;
+                break;
+            case 'lte':
+                if (fieldValue > opValue)
+                    return false;
+                break;
+            case 'gte':
+                if (fieldValue < opValue)
+                    return false;
+                break;
+            case 'in':
+                if (!Array.isArray(opValue) || !opValue.includes(fieldValue))
+                    return false;
+                break;
+            case 'isDefined': {
+                const exists = fieldValue !== undefined && fieldValue !== null;
+                if (opValue !== exists)
+                    return false;
+                break;
+            }
+            case 'contains':
+                if (typeof fieldValue !== 'string' || !fieldValue.includes(opValue))
+                    return false;
+                break;
+            case 'beginsWith':
+                if (typeof fieldValue !== 'string' || !fieldValue.startsWith(opValue))
+                    return false;
+                break;
+            case 'regex':
+                if (typeof fieldValue !== 'string')
+                    return false;
+                try {
+                    const regex = new RegExp(opValue);
+                    if (!regex.test(fieldValue))
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+                break;
+            case 'iRegex':
+                if (typeof fieldValue !== 'string')
+                    return false;
+                try {
+                    const regex = new RegExp(opValue, 'i');
+                    if (!regex.test(fieldValue))
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+                break;
+            case 'includes':
+                if (!Array.isArray(fieldValue))
+                    return false;
+                if (typeof opValue === 'string') {
+                    // Check if any element contains the string
+                    if (!fieldValue.some((item) => typeof item === 'string' && item.includes(opValue)))
+                        return false;
+                }
+                else {
+                    // Check if array includes the value (elemMatch-like)
+                    if (!fieldValue.some((item) => {
+                        if (typeof opValue === 'object' && opValue !== null) {
+                            return evaluateFilter(item, opValue);
+                        }
+                        return item === opValue;
+                    }))
+                        return false;
+                }
+                break;
+            default:
+                // If the key is not a known operator, it might be a nested filter
+                if (!evaluateFieldFilter(getNestedValue(fieldValue, op), filter[op])) {
+                    return false;
+                }
+        }
+    }
+    return true;
+}
+/**
+ * Converts a GraphQL filter to an evaluated filter structure.
+ * This function transforms Magek-style filters into a format that can be
+ * efficiently evaluated against data.
+ */
+function convertFilter(filters, prefix = '') {
+    const result = {};
+    for (const key in filters) {
+        const filterValue = filters[key];
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (key === 'and' || key === 'or') {
+            const logicalFilters = filterValue.map((f) => convertFilter(f));
+            result[`$${key}`] = logicalFilters;
+        }
+        else if (key === 'not') {
+            result['$not'] = convertFilter(filterValue);
+        }
+        else if (typeof filterValue === 'object' && filterValue !== null) {
+            // Check if this is a filter operation object
+            const opKeys = Object.keys(filterValue);
+            const isFilterOp = opKeys.some((k) => ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'in', 'isDefined', 'contains', 'beginsWith', 'regex', 'iRegex', 'includes'].includes(k));
+            if (isFilterOp) {
+                result[fullKey] = convertFilterOperation(filterValue);
+            }
+            else {
+                // Nested object filter
+                Object.assign(result, convertFilter(filterValue, fullKey));
+            }
+        }
+        else {
+            result[fullKey] = filterValue;
+        }
+    }
+    return result;
+}
+function convertFilterOperation(filter) {
+    const op = Object.keys(filter)[0];
+    const value = filter[op];
+    switch (op) {
+        case 'eq':
+            return { $eq: value };
+        case 'ne':
+            return { $ne: value };
+        case 'lt':
+            return { $lt: value };
+        case 'gt':
+            return { $gt: value };
+        case 'lte':
+            return { $lte: value };
+        case 'gte':
+            return { $gte: value };
+        case 'in':
+            return { $in: value };
+        case 'isDefined':
+            return { $exists: value };
+        case 'contains':
+        case 'beginsWith':
+        case 'regex':
+            return { $regex: new RegExp(op === 'beginsWith' ? `^${value}` : value) };
+        case 'iRegex':
+            return { $regex: new RegExp(value, 'i') };
+        case 'includes':
+            if (typeof value === 'string') {
+                return { $regex: new RegExp(value) };
+            }
+            return { $elemMatch: value };
+        default:
+            return value;
+    }
+}

package/dist/memory-read-model-registry.d.ts

@@ -0,0 +1,27 @@
+import { ReadModelEnvelope, SortFor, ProjectionFor, UUID } from '@magek/common';
+export interface ReadModelStoreEntry extends ReadModelEnvelope {
+    uniqueKey: string;
+}
+export declare class MemoryReadModelRegistry {
+    private readModels;
+    private byType;
+    private getKey;
+    query(query: QueryFilter, sortBy?: SortFor<unknown>, skip?: number, limit?: number, select?: ProjectionFor<unknown>): Promise<Array<ReadModelEnvelope>>;
+    store(readModel: ReadModelEnvelope, expectedCurrentVersion: number): Promise<void>;
+    deleteById(id: UUID, typeName: string): Promise<number>;
+    deleteAll(): Promise<number>;
+    count(query?: QueryFilter): Promise<number>;
+    getCount(): number;
+    private matchesFilter;
+    private getNestedValue;
+    private toLocalSortFor;
+    private sortResults;
+    private filterFields;
+    private setNestedValue;
+}
+export interface QueryFilter {
+    typeName?: string;
+    'value.id'?: UUID;
+    filters?: any;
+    [key: string]: any;
+}

package/dist/memory-read-model-registry.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryReadModelRegistry = void 0;
+const common_1 = require("@magek/common");
+const filter_evaluator_1 = require("./library/filter-evaluator");
+class MemoryReadModelRegistry {
+    readModels = new Map();
+    byType = new Map();
+    getKey(typeName, id) {
+        return `${typeName}:${id}`;
+    }
+    async query(query, sortBy, skip, limit, select) {
+        let results = [];
+        // Filter by typeName first if provided
+        if (query.typeName) {
+            const typeKeys = this.byType.get(query.typeName);
+            if (typeKeys) {
+                for (const key of Array.from(typeKeys)) {
+                    const entry = this.readModels.get(key);
+                    if (entry && this.matchesFilter(entry, query)) {
+                        results.push(entry);
+                    }
+                }
+            }
+        }
+        else {
+            // Query all read models
+            for (const entry of Array.from(this.readModels.values())) {
+                if (this.matchesFilter(entry, query)) {
+                    results.push(entry);
+                }
+            }
+        }
+        // Apply sorting
+        if (sortBy && Object.keys(sortBy).length > 0) {
+            const sortedList = this.toLocalSortFor(sortBy);
+            if (sortedList) {
+                results = this.sortResults(results, sortedList);
+            }
+        }
+        // Apply skip
+        if (skip && skip > 0) {
+            results = results.slice(skip);
+        }
+        // Apply limit
+        if (limit && limit > 0) {
+            results = results.slice(0, limit);
+        }
+        // Apply select (field projection)
+        if (select && select.length > 0) {
+            results = results.map((result) => ({
+                ...result,
+                value: this.filterFields(result.value, select),
+            }));
+        }
+        return results;
+    }
+    async store(readModel, expectedCurrentVersion) {
+        const key = this.getKey(readModel.typeName, readModel.value.id);
+        const version = readModel.value.magekMetadata?.version ?? 1;
+        const uniqueKey = `${readModel.typeName}_${readModel.value.id}_${version}`;
+        const entry = {
+            ...readModel,
+            uniqueKey,
+        };
+        if (version === 1) {
+            // Insert new read model
+            this.readModels.set(key, entry);
+            // Index by type
+            if (!this.byType.has(readModel.typeName)) {
+                this.byType.set(readModel.typeName, new Set());
+            }
+            this.byType.get(readModel.typeName).add(key);
+        }
+        else {
+            // Update existing read model with optimistic concurrency check
+            const existing = this.readModels.get(key);
+            if (!existing) {
+                throw new common_1.OptimisticConcurrencyUnexpectedVersionError(`Can't update readModel ${JSON.stringify(readModel)} with expectedCurrentVersion = ${expectedCurrentVersion}. Read model not found.`);
+            }
+            const existingVersion = existing.value.magekMetadata?.version ?? 0;
+            if (existingVersion !== expectedCurrentVersion) {
+                throw new common_1.OptimisticConcurrencyUnexpectedVersionError(`Can't update readModel ${JSON.stringify(readModel)} with expectedCurrentVersion = ${expectedCurrentVersion}. Current version is ${existingVersion}.`);
+            }
+            this.readModels.set(key, entry);
+        }
+    }
+    async deleteById(id, typeName) {
+        const key = this.getKey(typeName, id);
+        const exists = this.readModels.has(key);
+        if (exists) {
+            this.readModels.delete(key);
+            this.byType.get(typeName)?.delete(key);
+            return 1;
+        }
+        return 0;
+    }
+    async deleteAll() {
+        const count = this.readModels.size;
+        this.readModels.clear();
+        this.byType.clear();
+        return count;
+    }
+    async count(query) {
+        if (!query) {
+            return this.readModels.size;
+        }
+        let count = 0;
+        for (const entry of Array.from(this.readModels.values())) {
+            if (this.matchesFilter(entry, query)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    getCount() {
+        return this.readModels.size;
+    }
+    matchesFilter(entry, query) {
+        // Check typeName
+        if (query.typeName && entry.typeName !== query.typeName) {
+            return false;
+        }
+        // Check value.id
+        if (query['value.id'] && entry.value.id !== query['value.id']) {
+            return false;
+        }
+        // Check sequence key if present
+        for (const key of Object.keys(query)) {
+            if (key.startsWith('value.') && key !== 'value.id') {
+                const fieldPath = key.substring(6); // Remove 'value.' prefix
+                const fieldValue = this.getNestedValue(entry.value, fieldPath);
+                if (fieldValue !== query[key]) {
+                    return false;
+                }
+            }
+        }
+        // Check GraphQL-style filters
+        if (query.filters) {
+            if (!(0, filter_evaluator_1.evaluateFilter)(entry.value, query.filters)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    toLocalSortFor(sortBy, parentKey = '', sortedList = Object.create(null)) {
+        if (!sortBy || Object.keys(sortBy).length === 0)
+            return undefined;
+        Object.entries(sortBy).forEach(([key, value]) => {
+            if (typeof value === 'string') {
+                sortedList[`value.${parentKey}${key}`] = value === 'ASC' ? 1 : -1;
+            }
+            else {
+                this.toLocalSortFor(value, `${parentKey}${key}.`, sortedList);
+            }
+        });
+        return sortedList;
+    }
+    sortResults(results, sortedList) {
+        return [...results].sort((a, b) => {
+            for (const [path, direction] of Object.entries(sortedList)) {
+                const aValue = this.getNestedValue(a, path);
+                const bValue = this.getNestedValue(b, path);
+                if (aValue < bValue)
+                    return -1 * direction;
+                if (aValue > bValue)
+                    return 1 * direction;
+            }
+            return 0;
+        });
+    }
+    filterFields(obj, select) {
+        const result = Object.create(null);
+        select.forEach((field) => {
+            const parts = field.split('.');
+            this.setNestedValue(result, obj, parts);
+        });
+        return result;
+    }
+    setNestedValue(result, source, parts) {
+        let currentResult = result;
+        let currentSource = source;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            if (part.endsWith('[]')) {
+                const arrayField = part.slice(0, -2);
+                if (!Array.isArray(currentSource[arrayField])) {
+                    return;
+                }
+                if (!currentResult[arrayField]) {
+                    currentResult[arrayField] = [];
+                }
+                if (isLast) {
+                    currentResult[arrayField] = currentSource[arrayField];
+                }
+                else {
+                    currentSource[arrayField].forEach((item, index) => {
+                        if (!currentResult[arrayField][index]) {
+                            currentResult[arrayField][index] = Object.create(null);
+                        }
+                        this.setNestedValue(currentResult[arrayField][index], item, parts.slice(i + 1));
+                    });
+                }
+            }
+            else {
+                if (isLast) {
+                    if (currentSource[part] !== undefined) {
+                        currentResult[part] = currentSource[part];
+                    }
+                }
+                else {
+                    if (!currentSource[part]) {
+                        return;
+                    }
+                    if (!currentResult[part]) {
+                        currentResult[part] = Array.isArray(currentSource[part]) ? [] : Object.create(null);
+                    }
+                    currentResult = currentResult[part];
+                    currentSource = currentSource[part];
+                }
+            }
+        }
+    }
+}
+exports.MemoryReadModelRegistry = MemoryReadModelRegistry;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@magek/adapter-read-model-store-memory",
+  "version": "0.0.10",
+  "description": "In-memory read model store adapter for the Magek framework",
+  "keywords": [
+    "read-model-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"
+  }
+}