@magek/adapter-read-model-store-nedb 0.0.1

package/README.md

@@ -0,0 +1,43 @@
+# NeDB Read Model Store Adapter
+
+This package provides a NeDB-based read model store adapter for the Magek framework.
+
+## Installation
+
+```bash
+npm install @magek/adapter-read-model-store-nedb
+```
+
+## Usage
+
+```typescript
+import { MagekConfig } from '@magek/common'
+import { readModelStore } from '@magek/adapter-read-model-store-nedb'
+
+const config = new MagekConfig('development')
+config.readModelStoreAdapter = readModelStore
+```
+
+## Features
+
+- Full ReadModelStoreAdapter interface implementation
+- Support for fetch, search, store, and delete operations
+- Built-in health checks
+- Comprehensive query capabilities with filtering, sorting, and pagination
+- Optimistic concurrency control
+- Field projection support
+
+## API
+
+The adapter implements the standard `ReadModelStoreAdapter` interface:
+
+- `fetch(config, readModelName, readModelID)` - Fetch a single read model by ID
+- `search(config, readModelName, parameters)` - Search read models with filters
+- `store(config, readModelName, readModel)` - Store or update a read model
+- `delete(config, readModelName, readModelID)` - Delete a read model by ID
+- `rawToEnvelopes(rawReadModels)` - Convert raw data to read model envelopes
+- `healthCheck` - Health check methods (isUp, details, urls)
+
+## Storage
+
+Read models are stored in a local NeDB file at `.magek/read_models.json`.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { ReadModelStoreAdapter } from '@magek/common';
+export declare const readModelStore: ReadModelStoreAdapter;
+export { ReadModelRegistry } from './read-model-registry';
+export { fetchReadModel, storeReadModel, searchReadModel, deleteReadModel, } from './library/read-model-adapter';
+export { queryRecordFor } from './library/searcher-adapter';

package/dist/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRecordFor = exports.deleteReadModel = exports.searchReadModel = exports.storeReadModel = exports.fetchReadModel = exports.ReadModelRegistry = exports.readModelStore = void 0;
+const read_model_registry_1 = require("./read-model-registry");
+const read_model_adapter_1 = require("./library/read-model-adapter");
+const paths_1 = require("./paths");
+const fs_1 = require("fs");
+// Pre-built NeDB Read Model Store Adapter instance
+const readModelRegistry = new read_model_registry_1.ReadModelRegistry();
+async function countAll(database) {
+    await database.loadDatabaseIfNeeded();
+    const count = await database.readModels.countAsync({});
+    return count !== null && count !== void 0 ? count : 0;
+}
+exports.readModelStore = {
+    fetch: async (config, readModelName, readModelID, sequenceKey) => {
+        const result = await (0, read_model_adapter_1.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 (0, read_model_adapter_1.searchReadModel)(readModelRegistry, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion !== null && paginatedVersion !== void 0 ? paginatedVersion : false, select);
+    },
+    store: async (config, readModelName, readModel) => {
+        var _a;
+        const expectedCurrentVersion = ((_a = readModel.version) !== null && _a !== void 0 ? _a : 1) - 1;
+        await (0, read_model_adapter_1.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 (0, read_model_adapter_1.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 () => (0, fs_1.existsSync)(paths_1.readModelsDatabase),
+        details: async () => {
+            const count = await countAll(readModelRegistry);
+            return {
+                file: paths_1.readModelsDatabase,
+                count: count,
+            };
+        },
+        urls: async () => [paths_1.readModelsDatabase],
+    },
+};
+// Export individual components for backward compatibility
+var read_model_registry_2 = require("./read-model-registry");
+Object.defineProperty(exports, "ReadModelRegistry", { enumerable: true, get: function () { return read_model_registry_2.ReadModelRegistry; } });
+var read_model_adapter_2 = require("./library/read-model-adapter");
+Object.defineProperty(exports, "fetchReadModel", { enumerable: true, get: function () { return read_model_adapter_2.fetchReadModel; } });
+Object.defineProperty(exports, "storeReadModel", { enumerable: true, get: function () { return read_model_adapter_2.storeReadModel; } });
+Object.defineProperty(exports, "searchReadModel", { enumerable: true, get: function () { return read_model_adapter_2.searchReadModel; } });
+Object.defineProperty(exports, "deleteReadModel", { enumerable: true, get: function () { return read_model_adapter_2.deleteReadModel; } });
+var searcher_adapter_1 = require("./library/searcher-adapter");
+Object.defineProperty(exports, "queryRecordFor", { enumerable: true, get: function () { return searcher_adapter_1.queryRecordFor; } });

package/dist/library/read-model-adapter.d.ts

@@ -0,0 +1,7 @@
+import { MagekConfig, FilterFor, ProjectionFor, ReadModelEnvelope, ReadModelInterface, ReadModelListResult, ReadOnlyNonEmptyArray, SequenceKey, SortFor, UUID } from '@magek/common';
+import { ReadModelRegistry } from '../read-model-registry';
+export declare function rawReadModelEventsToEnvelopes(config: MagekConfig, rawEvents: Array<unknown>): Promise<Array<ReadModelEnvelope>>;
+export declare function fetchReadModel(db: ReadModelRegistry, config: MagekConfig, readModelName: string, readModelID: UUID, sequenceKey?: SequenceKey): Promise<ReadOnlyNonEmptyArray<ReadModelInterface> | undefined>;
+export declare function storeReadModel(db: ReadModelRegistry, config: MagekConfig, readModelName: string, readModel: ReadModelInterface, expectedCurrentVersion: number): Promise<void>;
+export declare function searchReadModel<TReadModel extends ReadModelInterface>(db: ReadModelRegistry, 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>>;
+export declare function deleteReadModel(db: ReadModelRegistry, config: MagekConfig, readModelName: string, readModel: ReadModelInterface): Promise<void>;

package/dist/library/read-model-adapter.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawReadModelEventsToEnvelopes = rawReadModelEventsToEnvelopes;
+exports.fetchReadModel = fetchReadModel;
+exports.storeReadModel = storeReadModel;
+exports.searchReadModel = searchReadModel;
+exports.deleteReadModel = deleteReadModel;
+const common_1 = require("@magek/common");
+const read_model_registry_1 = require("../read-model-registry");
+const searcher_adapter_1 = require("./searcher-adapter");
+async function rawReadModelEventsToEnvelopes(config, rawEvents) {
+    return rawEvents;
+}
+async function fetchReadModel(db, config, readModelName, readModelID, sequenceKey) {
+    const logger = (0, common_1.getLogger)(config, 'read-model-adapter#fetchReadModel');
+    let 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, 'read-model-adapter#storeReadModel');
+    logger.debug('Storing readModel ' + JSON.stringify(readModel));
+    try {
+        await db.store({ typeName: readModelName, value: readModel }, expectedCurrentVersion);
+    }
+    catch (e) {
+        const error = e;
+        // The error will be thrown, but in case of a conditional check, we throw the expected error type by the core
+        if (error.errorType == read_model_registry_1.UNIQUE_VIOLATED_ERROR_TYPE) {
+            logger.warn(`Unique violated storing ReadModel ${JSON.stringify(readModel)} and expectedCurrentVersion ${expectedCurrentVersion}`);
+            throw new common_1.OptimisticConcurrencyUnexpectedVersionError(error.message);
+        }
+        throw e;
+    }
+    logger.debug('Read model stored');
+}
+async function searchReadModel(db, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion = false, select) {
+    var _a, _b;
+    const logger = (0, common_1.getLogger)(config, 'read-model-adapter#searchReadModel');
+    logger.debug('Converting filter to query');
+    const queryFor = (0, searcher_adapter_1.queryRecordFor)(filters);
+    const query = { ...queryFor, typeName: readModelName };
+    logger.debug('Got query ', query);
+    const skipId = (afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) ? parseInt(afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) : 0;
+    const result = await db.query(query, sortBy, skipId, limit, select);
+    logger.debug('Search result: ', result);
+    const items = (_a = result === null || result === void 0 ? void 0 : result.map((envelope) => envelope.value)) !== null && _a !== void 0 ? _a : [];
+    if (paginatedVersion) {
+        return {
+            items: items,
+            count: (_b = items === null || items === void 0 ? void 0 : items.length) !== null && _b !== void 0 ? _b : 0,
+            cursor: { id: ((limit ? limit : 1) + skipId).toString() },
+        };
+    }
+    return items;
+}
+async function deleteReadModel(db, config, readModelName, readModel) {
+    const logger = (0, common_1.getLogger)(config, '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`);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { FilterFor } from '@magek/common';
+/**
+ * Creates a query record out of the read mode name and
+ * the GraphQL filters, ready to be passed into the `query`
+ * method of the read model registry.
+ */
+export declare function queryRecordFor(filters: FilterFor<any>, nested?: string, queryFromFilters?: Record<string, object>): Record<string, QueryOperation<QueryValue>>;
+export type QueryValue = number | string | boolean;
+export type QueryOperation<TValue> = TValue | {
+    [TKey in '$lt' | '$lte' | '$gt' | '$gte' | '$ne' | '$exists']?: TValue;
+} | {
+    [TKey in '$in' | '$nin']?: Array<TValue>;
+} | {
+    [TKey in '$regex' | '$nin']?: RegExp;
+} | {
+    [TKey in '$elemMatch']?: TValue;
+};

package/dist/library/searcher-adapter.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRecordFor = queryRecordFor;
+/**
+ * Creates a query record out of the read mode name and
+ * the GraphQL filters, ready to be passed into the `query`
+ * method of the read model registry.
+ */
+function queryRecordFor(filters, nested, queryFromFilters = {}) {
+    if (Object.keys(filters).length != 0) {
+        for (const key in filters) {
+            const propName = nested ? `${nested}.${key}` : key;
+            const filter = filters[key];
+            switch (key) {
+                case 'not':
+                    queryFromFilters[`$${propName}`] = queryRecordFor(filter);
+                    break;
+                case 'or':
+                case 'and':
+                    queryFromFilters[`$${propName}`] = filters[key].map((filter) => queryRecordFor(filter));
+                    break;
+                default:
+                    if (!Object.keys(queryOperatorTable).includes(Object.keys(filter)[0])) {
+                        queryRecordFor(filter, propName, queryFromFilters);
+                    }
+                    else {
+                        queryFromFilters[`value.${propName}`] = filterToQuery(filter);
+                    }
+                    break;
+            }
+        }
+    }
+    return { ...queryFromFilters };
+}
+/**
+ * Transforms a GraphQL Magek filter into an neDB query
+ */
+function filterToQuery(filter) {
+    const [query] = Object.entries(filter).map(([propName, filter]) => {
+        const query = queryOperatorTable[propName];
+        const queryFilter = Array.isArray(filter) ? filter : [filter];
+        return query(queryFilter);
+    });
+    return query;
+}
+/**
+ * Table of equivalences between a GraphQL operation and the NeDB
+ * query operator.
+ *
+ * It is needed that we pass the values, because of the special case
+ * of `=`, in which the operator is the value itself.
+ */
+const queryOperatorTable = {
+    eq: (values) => values[0],
+    ne: (values) => ({ $ne: values[0] }),
+    lt: (values) => ({ $lt: values[0] }),
+    gt: (values) => ({ $gt: values[0] }),
+    lte: (values) => ({ $lte: values[0] }),
+    gte: (values) => ({ $gte: values[0] }),
+    in: (values) => ({ $in: values }),
+    isDefined: (values) => ({ $exists: values[0] }),
+    contains: buildRegexQuery.bind(null, 'contains'),
+    beginsWith: buildRegexQuery.bind(null, 'begins-with'),
+    includes: buildIncludes.bind(null, 'contains'),
+    regex: buildRegexQuery.bind(null, 'regex'),
+    iRegex: buildRegexQuery.bind(null, 'iRegex'),
+};
+function buildIncludes(operation, values) {
+    const matcher = values[0];
+    if (typeof matcher === 'string') {
+        return { $regex: new RegExp(matcher) };
+    }
+    return { $elemMatch: matcher };
+}
+/**
+ * Builds a regex out of string GraphQL queries
+ */
+function buildRegexQuery(operation, values) {
+    const matcher = values[0];
+    if (typeof matcher != 'string') {
+        throw new Error(`Attempted to perform a ${operation} operation on a non-string`);
+    }
+    if (operation === 'begins-with') {
+        return { $regex: new RegExp(`^${matcher}`) };
+    }
+    if (operation === 'iRegex') {
+        return { $regex: new RegExp(matcher, 'i') };
+    }
+    return { $regex: new RegExp(matcher) };
+}

package/dist/paths.d.ts

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

package/dist/paths.js

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

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

@@ -0,0 +1,23 @@
+import { ProjectionFor, ReadModelEnvelope, SortFor, UUID } from '@magek/common';
+interface LocalSortedFor {
+    [key: string]: number;
+}
+export type NedbError = Error & {
+    [key: string | number | symbol]: unknown;
+};
+export declare const UNIQUE_VIOLATED_ERROR_TYPE = "uniqueViolated";
+export declare class ReadModelRegistry {
+    readonly readModels: any;
+    isLoaded: boolean;
+    constructor();
+    loadDatabaseIfNeeded(): Promise<void>;
+    query(query: object, sortBy?: SortFor<unknown>, skip?: number, limit?: number, select?: ProjectionFor<unknown>): Promise<Array<ReadModelEnvelope>>;
+    store(readModel: ReadModelEnvelope, expectedCurrentVersion: number): Promise<void>;
+    private insert;
+    private update;
+    deleteById(id: UUID, typeName: string): Promise<number>;
+    toLocalSortFor(sortBy?: SortFor<unknown>, parentKey?: string, sortedList?: LocalSortedFor): undefined | LocalSortedFor;
+    filterFields(obj: any, select: string[]): any;
+    setNestedValue(result: any, source: any, parts: string[]): void;
+}
+export {};

package/dist/read-model-registry.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadModelRegistry = exports.UNIQUE_VIOLATED_ERROR_TYPE = void 0;
+const paths_1 = require("./paths");
+const DataStore = require('@seald-io/nedb');
+exports.UNIQUE_VIOLATED_ERROR_TYPE = 'uniqueViolated';
+class ReadModelRegistry {
+    constructor() {
+        this.isLoaded = false;
+        this.readModels = new DataStore({ filename: paths_1.readModelsDatabase });
+    }
+    async loadDatabaseIfNeeded() {
+        if (!this.isLoaded) {
+            this.isLoaded = true;
+            await this.readModels.loadDatabaseAsync();
+            await this.readModels.ensureIndexAsync({ fieldName: 'uniqueKey', unique: true, sparse: true });
+        }
+    }
+    async query(query, sortBy, skip, limit, select) {
+        await this.loadDatabaseIfNeeded();
+        let cursor = this.readModels.find(query);
+        const sortByList = this.toLocalSortFor(sortBy);
+        if (sortByList) {
+            cursor = cursor.sort(sortByList);
+        }
+        if (skip) {
+            cursor = cursor.skip(skip);
+        }
+        if (limit) {
+            cursor = cursor.limit(limit);
+        }
+        // Fetch results from the cursor
+        const results = await cursor.execAsync();
+        // Process each result to filter the array fields
+        if (select && select.length > 0) {
+            results.forEach((result) => {
+                result.value = this.filterFields(result.value, select);
+            });
+        }
+        return results;
+    }
+    async store(readModel, expectedCurrentVersion) {
+        var _a, _b;
+        await this.loadDatabaseIfNeeded();
+        const uniqueReadModel = readModel;
+        uniqueReadModel.uniqueKey = `${readModel.typeName}_${readModel.value.id}_${(_a = readModel.value.magekMetadata) === null || _a === void 0 ? void 0 : _a.version}`;
+        if (((_b = uniqueReadModel.value.magekMetadata) === null || _b === void 0 ? void 0 : _b.version) === 1) {
+            return this.insert(readModel);
+        }
+        return this.update(uniqueReadModel, expectedCurrentVersion);
+    }
+    async insert(readModel) {
+        await this.loadDatabaseIfNeeded();
+        await this.readModels.insertAsync(readModel);
+    }
+    async update(readModel, expectedCurrentVersion) {
+        await this.loadDatabaseIfNeeded();
+        const { numAffected } = await this.readModels.updateAsync({
+            typeName: readModel.typeName,
+            'value.id': readModel.value.id,
+            'value.magekMetadata.version': expectedCurrentVersion,
+        }, readModel, { upsert: false, returnUpdatedDocs: true });
+        if (numAffected === 0) {
+            const error = new Error(`Can't update readModel ${JSON.stringify(readModel)} with expectedCurrentVersion = ${expectedCurrentVersion} . Optimistic concurrency error`);
+            error.errorType = exports.UNIQUE_VIOLATED_ERROR_TYPE;
+            throw error;
+        }
+    }
+    async deleteById(id, typeName) {
+        await this.loadDatabaseIfNeeded();
+        return await this.readModels.removeAsync({ typeName: typeName, 'value.id': id }, { multi: false });
+    }
+    toLocalSortFor(sortBy, parentKey = '', sortedList = Object.create(null)) {
+        if (!sortBy || Object.keys(sortBy).length === 0)
+            return;
+        const elements = sortBy;
+        Object.entries(elements).forEach(([key, value]) => {
+            if (typeof value === 'string') {
+                sortedList[`value.${parentKey}${key}`] = value === 'ASC' ? 1 : -1;
+            }
+            else {
+                this.toLocalSortFor(value, `${parentKey}${key}.`, sortedList);
+            }
+        });
+        return sortedList;
+    }
+    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.ReadModelRegistry = ReadModelRegistry;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@magek/adapter-read-model-store-nedb",
+  "version": "0.0.1",
+  "description": "Nedb-based read model store adapter for the Magek framework",
+  "keywords": [
+    "read-model-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\""
+  }
+}