@hapiboo/flux 1.0.0

package/dist/conditions.d.ts

@@ -0,0 +1,10 @@
+import { FluxDBFilterOperator, FluxDBFilterLogic, FluxDBFilterOperatorValues, FluxDBFilterOperatorCollection } from './types';
+import { IFluxDBCondition, IFluxDBSubCondition } from './interfaces';
+export declare namespace conditionBuilder {
+    function createSimpleBooleanCondition(column: string, operator: FluxDBFilterOperator, value: boolean): IFluxDBCondition;
+    function createSimpleStringOrNumberCondition(column: string, operator: FluxDBFilterOperator, value: string | number | undefined): IFluxDBCondition;
+    function createSimpleNumberCondition(column: string, operator: FluxDBFilterOperatorValues, value: number): IFluxDBCondition;
+    function createSimpleNumberCollectionCondition(column: string, operator: FluxDBFilterOperatorCollection, value: number[]): IFluxDBCondition;
+    function createSimpleStringCollectionCondition(column: string, operator: FluxDBFilterOperatorCollection, value: string[]): IFluxDBCondition;
+    function createSubCondition(logic: FluxDBFilterLogic, conditions: IFluxDBCondition[]): IFluxDBSubCondition;
+}

package/dist/conditions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditionBuilder = void 0;
+var conditionBuilder;
+(function (conditionBuilder) {
+    function createSimpleBooleanCondition(column, operator, value) {
+        return { column, operator, value };
+    }
+    conditionBuilder.createSimpleBooleanCondition = createSimpleBooleanCondition;
+    function createSimpleStringOrNumberCondition(column, operator, value) {
+        return { column, operator, value };
+    }
+    conditionBuilder.createSimpleStringOrNumberCondition = createSimpleStringOrNumberCondition;
+    function createSimpleNumberCondition(column, operator, value) {
+        return { column, operator, value };
+    }
+    conditionBuilder.createSimpleNumberCondition = createSimpleNumberCondition;
+    function createSimpleNumberCollectionCondition(column, operator, value) {
+        return { column, operator, value };
+    }
+    conditionBuilder.createSimpleNumberCollectionCondition = createSimpleNumberCollectionCondition;
+    function createSimpleStringCollectionCondition(column, operator, value) {
+        return { column, operator, value };
+    }
+    conditionBuilder.createSimpleStringCollectionCondition = createSimpleStringCollectionCondition;
+    function createSubCondition(logic, conditions) {
+        return { logic, conditions };
+    }
+    conditionBuilder.createSubCondition = createSubCondition;
+})(conditionBuilder || (exports.conditionBuilder = conditionBuilder = {}));

package/dist/decorators.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { FluxColumnPrimary, FluxObjectCreator } from './types';
+import { IFluxColumnInfo } from './interfaces';
+export declare function FluxTable(name: string): ClassDecorator;
+export declare function FluxIdentifier(): PropertyDecorator;
+export declare function FluxExposedColumn(name: string, type?: FluxColumnPrimary): PropertyDecorator;
+export declare function FluxIndex(name: string, key: string, sort: string | undefined): ClassDecorator;
+export declare namespace hapibooDecorators {
+    function getTableName(target: FluxObjectCreator): string;
+    function getIdentifierProperty(target: FluxObjectCreator): string;
+    function getIndexesInfo(target: FluxObjectCreator): {
+        name: string;
+        key: string;
+        sort: string | undefined;
+    }[];
+    function getColumnsInfo(target: FluxObjectCreator): {
+        info: IFluxColumnInfo;
+        propertyKey: string | symbol;
+    }[];
+}

package/dist/decorators.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hapibooDecorators = void 0;
+exports.FluxTable = FluxTable;
+exports.FluxIdentifier = FluxIdentifier;
+exports.FluxExposedColumn = FluxExposedColumn;
+exports.FluxIndex = FluxIndex;
+require("reflect-metadata");
+const types_1 = require("./types");
+const META_TABLE = Symbol('meta:class:table');
+const META_INDEX = Symbol('meta:class:index');
+const META_IDENTIFIER = Symbol('meta:field:id');
+const META_COLUMN = Symbol('meta:field:column');
+function FluxTable(name) {
+    return target => {
+        Reflect.defineMetadata(META_TABLE, { name }, target);
+    };
+}
+function FluxIdentifier() {
+    return (target, key) => {
+        Reflect.defineMetadata(META_IDENTIFIER, { propertyKey: key }, target.constructor);
+    };
+}
+function FluxExposedColumn(name, type = types_1.FluxColumnPrimary.String) {
+    return (target, key) => {
+        const fields = Reflect.getMetadata(META_COLUMN, target.constructor) || [];
+        fields.push({ propertyKey: key, info: { name, type } });
+        Reflect.defineMetadata(META_COLUMN, fields, target.constructor);
+    };
+}
+function FluxIndex(name, key, sort) {
+    return target => {
+        const indexes = Reflect.getMetadata(META_INDEX, target) || [];
+        indexes.push({ name, key, sort });
+        Reflect.defineMetadata(META_INDEX, indexes, target);
+    };
+}
+var hapibooDecorators;
+(function (hapibooDecorators) {
+    function getTableName(target) {
+        const metadata = Reflect.getMetadata(META_TABLE, target);
+        return metadata ? metadata.name : 'storage_table';
+    }
+    hapibooDecorators.getTableName = getTableName;
+    function getIdentifierProperty(target) {
+        const metadata = Reflect.getMetadata(META_IDENTIFIER, target);
+        return metadata ? metadata.propertyKey : 'id';
+    }
+    hapibooDecorators.getIdentifierProperty = getIdentifierProperty;
+    function getIndexesInfo(target) {
+        const metadata = Reflect.getMetadata(META_INDEX, target);
+        return metadata ? metadata : [];
+    }
+    hapibooDecorators.getIndexesInfo = getIndexesInfo;
+    function getColumnsInfo(target) {
+        const metadata = Reflect.getMetadata(META_COLUMN, target);
+        return metadata ? metadata : [];
+    }
+    hapibooDecorators.getColumnsInfo = getColumnsInfo;
+})(hapibooDecorators || (exports.hapibooDecorators = hapibooDecorators = {}));

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { IFluxIndexInfo, IFluxColumnInfo, IFluxIndexData, IFluxDataModel, IFluxDataModelDefinition, IFluxDataModelWriter, IFluxDataModelReader, IFluxDBFilter, IFluxDBCondition, IFluxDBSubCondition, IFluxObject, IFluxModule, IDBProviderFlux } from './interfaces';
+import { FluxColumn, FluxColumnPrimary, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorValues, FluxDBFilterOperatorCollection } from './types';
+import { FluxTable, FluxIndex, FluxExposedColumn, FluxIdentifier } from './decorators';
+import { fluxApplication } from './module';
+import { conditionBuilder } from './conditions';
+export { FluxColumn, FluxColumnPrimary };
+export { IFluxIndexInfo, IFluxColumnInfo, IFluxIndexData };
+export { IFluxDataModel, IFluxDataModelDefinition, IFluxDataModelWriter, IFluxDataModelReader };
+export { IFluxDBFilter, IFluxDBCondition, IFluxDBSubCondition };
+export { FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorValues, FluxDBFilterOperatorCollection };
+export { IFluxObject, IFluxModule };
+export { IDBProviderFlux };
+export { conditionBuilder };
+export { fluxApplication };
+export { FluxTable, FluxIndex, FluxExposedColumn, FluxIdentifier };

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluxIdentifier = exports.FluxExposedColumn = exports.FluxIndex = exports.FluxTable = exports.fluxApplication = exports.conditionBuilder = exports.FluxColumnPrimary = exports.FluxColumn = void 0;
+const types_1 = require("./types");
+Object.defineProperty(exports, "FluxColumn", { enumerable: true, get: function () { return types_1.FluxColumn; } });
+Object.defineProperty(exports, "FluxColumnPrimary", { enumerable: true, get: function () { return types_1.FluxColumnPrimary; } });
+const decorators_1 = require("./decorators");
+Object.defineProperty(exports, "FluxTable", { enumerable: true, get: function () { return decorators_1.FluxTable; } });
+Object.defineProperty(exports, "FluxIndex", { enumerable: true, get: function () { return decorators_1.FluxIndex; } });
+Object.defineProperty(exports, "FluxExposedColumn", { enumerable: true, get: function () { return decorators_1.FluxExposedColumn; } });
+Object.defineProperty(exports, "FluxIdentifier", { enumerable: true, get: function () { return decorators_1.FluxIdentifier; } });
+const module_1 = require("./module");
+Object.defineProperty(exports, "fluxApplication", { enumerable: true, get: function () { return module_1.fluxApplication; } });
+const conditions_1 = require("./conditions");
+Object.defineProperty(exports, "conditionBuilder", { enumerable: true, get: function () { return conditions_1.conditionBuilder; } });

package/dist/interfaces.d.ts

@@ -0,0 +1,59 @@
+import { Dictionary, IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+import { FluxColumnPrimary, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorCollection, FluxDBFilterOperatorValues, FluxObjectCreator } from './types';
+export interface IFluxColumnInfo {
+    name: string;
+    type: FluxColumnPrimary;
+}
+export interface IFluxIndexInfo {
+    name: string;
+    key: IFluxColumnInfo;
+    sort: IFluxColumnInfo | undefined;
+}
+export interface IFluxIndexData {
+    key: string | number;
+    sort: string | number | undefined;
+}
+export interface IFluxDataModel {
+    table: string;
+    id: string;
+}
+export interface IFluxDataModelDefinition extends IFluxDataModel {
+    indexes: IFluxIndexInfo[];
+}
+export interface IFluxDataModelWriter extends IFluxDataModel {
+    columns: IFluxColumnInfo[];
+    values: Dictionary<string, string | number | boolean | Buffer | object[] | object>;
+}
+export interface IFluxDataModelReader<T> extends IFluxDataModel {
+    clone(model: T): T;
+}
+export interface IFluxDBCondition {
+    column: string;
+    operator: FluxDBFilterOperator | FluxDBFilterOperatorValues | FluxDBFilterOperatorCollection;
+    value: string | number | boolean | string[] | number[] | undefined;
+}
+export interface IFluxDBSubCondition {
+    conditions: (IFluxDBCondition | IFluxDBSubCondition)[];
+    logic: FluxDBFilterLogic;
+}
+export interface IFluxDBFilter {
+    condition: IFluxDBCondition | IFluxDBSubCondition;
+}
+export interface IDBProviderFlux {
+    init(model: IFluxDataModelDefinition): IResponsePromiseVoid;
+    read<T extends IFluxObject>(creator: IFluxDataModelReader<T>): IResponsePromise<T>;
+    array<T extends IFluxObject>(creator: IFluxDataModelReader<T>, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+    query<T extends IFluxObject>(creator: IFluxDataModelReader<T>, info: IFluxIndexInfo, data: IFluxIndexData, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+    create<T extends IFluxObject>(model: IFluxDataModelWriter, item: T): IResponsePromise<T>;
+    update<T extends IFluxObject>(model: IFluxDataModelWriter, item: T): IResponsePromise<T>;
+    delete(model: IFluxDataModel): IResponsePromiseVoid;
+}
+export interface IFluxObject {
+    clone(model: this): this;
+}
+export interface IFluxModule {
+    name: string;
+    models: FluxObjectCreator[];
+    initialize(): void;
+    start?: () => IResponsePromiseVoid;
+}

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/module.d.ts

@@ -0,0 +1,17 @@
+import { IResponsePromiseVoid, IResponsePromise } from '@hapiboo/core';
+import { IDBProviderFlux, IFluxModule, IFluxObject, IFluxDBFilter, IFluxIndexData } from './interfaces';
+import { FluxObjectCreator } from './types';
+export declare namespace fluxApplication {
+    function registerModule(module: IFluxModule): void;
+    function initialize(dbProvider: IDBProviderFlux): void;
+    function start(): IResponsePromiseVoid;
+    namespace repository {
+        function initializeModels(): IResponsePromiseVoid;
+        function deleteModel(source: FluxObjectCreator, identifier: string): IResponsePromiseVoid;
+        function createModel<T extends IFluxObject>(source: FluxObjectCreator, item: T): IResponsePromise<T>;
+        function updateModel<T extends IFluxObject>(source: FluxObjectCreator, item: T): IResponsePromise<T>;
+        function readModel<T extends IFluxObject>(source: FluxObjectCreator, identifier: string): IResponsePromise<T>;
+        function readArray<T extends IFluxObject>(source: FluxObjectCreator, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+        function queryArray<T extends IFluxObject>(source: FluxObjectCreator, index: string, data: IFluxIndexData, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+    }
+}

package/dist/module.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fluxApplication = void 0;
+const core_1 = require("@hapiboo/core");
+const decorators_1 = require("./decorators");
+var fluxApplication;
+(function (fluxApplication) {
+    const models = [];
+    const modules = [];
+    let _dbProvider;
+    function registerModule(module) {
+        modules.push(module);
+        console.info(`Registering module: ${module.name} with ${module.models.length} models.`);
+        module.models.forEach((model) => {
+            models.push(model);
+            objects.bootstrap(model);
+        });
+    }
+    fluxApplication.registerModule = registerModule;
+    function initialize(dbProvider) {
+        _dbProvider = dbProvider;
+        console.info(`Initializing application with ${modules.length} modules and ${models.length} models.`);
+        modules.forEach((module) => {
+            module.initialize();
+        });
+    }
+    fluxApplication.initialize = initialize;
+    function start() {
+        return core_1.promise.createDelayedVoidPromise((resolve, reject) => {
+            console.info('Starting application...');
+            core_1.promise.checkVoid(repository.initializeModels(), reject)
+                .then(() => {
+                core_1.promise.resolveVoid(startModule([...modules]), resolve, reject);
+            });
+        });
+    }
+    fluxApplication.start = start;
+    function startModule(modules) {
+        return core_1.promise.createDelayedVoidPromise((resolve, reject) => {
+            if (modules.length === 0) {
+                resolve();
+            }
+            else {
+                const module = modules.pop();
+                if (module.start) {
+                    console.info(`Starting module: ${module.name}...`);
+                    core_1.promise.checkVoid(module.start(), reject)
+                        .then(() => {
+                        core_1.promise.resolveVoid(startModule(modules), resolve, reject);
+                    });
+                }
+                else {
+                    core_1.promise.resolveVoid(startModule(modules), resolve, reject);
+                }
+            }
+        });
+    }
+    let objects;
+    (function (objects) {
+        const modelCache = new Map();
+        const columnCache = new Map();
+        const idCache = new Map();
+        const indexesCache = new Map();
+        function getValue(source, propertyKey) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return source[propertyKey];
+        }
+        function getModel(source) {
+            const model = modelCache.get(source);
+            if (!model) {
+                throw new Error(`Model definition for ${source.name} not found.`);
+            }
+            return model;
+        }
+        objects.getModel = getModel;
+        function bootstrap(source) {
+            //table+indexes                 TABLE
+            //table+clone                   READ/QUERY ARRAY
+            //table+id+columns+values x2    CREATE/UPDATE
+            //table+id+clone                READ ONE
+            //table+id                      DELETE
+            if (modelCache.has(source))
+                return;
+            const tableName = decorators_1.hapibooDecorators.getTableName(source);
+            const columnsInfo = decorators_1.hapibooDecorators.getColumnsInfo(source);
+            const identifierKey = decorators_1.hapibooDecorators.getIdentifierProperty(source);
+            const indexesInfo = decorators_1.hapibooDecorators.getIndexesInfo(source);
+            const indexes = indexesInfo.map((index) => {
+                const kCol = columnsInfo.find(col => col.info.name === index.key);
+                const sCOl = index.sort ? columnsInfo.find(col => col.info.name === index.sort) : undefined;
+                if (!kCol) {
+                    throw new Error(`Index key column '${index.key}' not found in model '${source.name}'.`);
+                }
+                if (index.sort && !sCOl) {
+                    throw new Error(`Index sort column '${index.sort}' not found in model '${source.name}'.`);
+                }
+                return {
+                    name: index.name,
+                    key: kCol.info,
+                    sort: sCOl?.info
+                };
+            });
+            modelCache.set(source, { table: tableName, id: '' });
+            columnCache.set(source, columnsInfo);
+            idCache.set(source, identifierKey);
+            indexesCache.set(source, indexes);
+        }
+        objects.bootstrap = bootstrap;
+        function getModelDefinition(source) {
+            const model = getModel(source);
+            return {
+                table: model.table,
+                id: model.id,
+                indexes: indexesCache.get(source) || []
+            };
+        }
+        objects.getModelDefinition = getModelDefinition;
+        function getModelWriter(source, item) {
+            const model = getModel(source);
+            const columns = columnCache.get(source) || [];
+            const identifierKey = idCache.get(source) || 'id';
+            const values = new core_1.Dictionary();
+            columns.forEach((col) => {
+                const value = getValue(item, col.propertyKey);
+                if (value !== undefined) {
+                    values.push(col.info.name, value);
+                }
+            });
+            return {
+                table: model.table,
+                id: getValue(item, identifierKey),
+                columns: columns.map(col => col.info),
+                values: values
+            };
+        }
+        objects.getModelWriter = getModelWriter;
+        function getModelReader(source, identifier) {
+            const model = getModel(source);
+            return {
+                table: model.table,
+                id: identifier,
+                clone: (m) => source.prototype.clone.call(new source(), m)
+            };
+        }
+        objects.getModelReader = getModelReader;
+        function getIndexInfo(source, index) {
+            const indexes = indexesCache.get(source);
+            if (!indexes) {
+                throw new Error(`Indexes for model '${source.name}' not found.`);
+            }
+            const idx = indexes.find(idx => idx.name === index);
+            if (!idx) {
+                throw new Error(`Index '${index}' for model '${source.name}' not found.`);
+            }
+            return idx;
+        }
+        objects.getIndexInfo = getIndexInfo;
+    })(objects || (objects = {}));
+    let repository;
+    (function (repository) {
+        function initializeModels() {
+            return core_1.promise.createDelayedVoidPromise((resolve, reject) => {
+                const initPromises = [];
+                core_1.promise.tryMethod(() => {
+                    for (const provider of models) {
+                        const modelDef = objects.getModelDefinition(provider);
+                        initPromises.push(_dbProvider.init(modelDef));
+                    }
+                }, reject).then(() => {
+                    core_1.promise.resolveVoid(core_1.promise.all(initPromises), resolve, reject);
+                });
+            });
+        }
+        repository.initializeModels = initializeModels;
+        function deleteModel(source, identifier) {
+            return core_1.promise.createDelayedVoidPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    return objects.getModel(source);
+                }, reject).then((model) => {
+                    core_1.promise.resolveVoid(_dbProvider.delete({ table: model.table, id: identifier }), resolve, reject);
+                });
+            });
+        }
+        repository.deleteModel = deleteModel;
+        function createModel(source, item) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    const model = objects.getModelWriter(source, item);
+                    return model;
+                }, reject).then((model) => {
+                    core_1.promise.resolve(_dbProvider.create(model, item), resolve, reject);
+                });
+            });
+        }
+        repository.createModel = createModel;
+        function updateModel(source, item) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    const model = objects.getModelWriter(source, item);
+                    return model;
+                }, reject).then((model) => {
+                    core_1.promise.resolve(_dbProvider.update(model, item), resolve, reject);
+                });
+            });
+        }
+        repository.updateModel = updateModel;
+        function readModel(source, identifier) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    return objects.getModelReader(source, identifier);
+                }, reject).then((reader) => {
+                    core_1.promise.resolve(_dbProvider.read(reader), resolve, reject);
+                });
+            });
+        }
+        repository.readModel = readModel;
+        function readArray(source, filter, queryLimit) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    return objects.getModelReader(source, '');
+                }, reject).then((reader) => {
+                    core_1.promise.resolve(_dbProvider.array(reader, filter, queryLimit), resolve, reject);
+                });
+            });
+        }
+        repository.readArray = readArray;
+        function queryArray(source, index, data, filter, queryLimit) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.tryMethod(() => {
+                    return { reader: objects.getModelReader(source, ''), info: objects.getIndexInfo(source, index) };
+                }, reject).then((information) => {
+                    core_1.promise.resolve(_dbProvider.query(information.reader, information.info, data, filter, queryLimit), resolve, reject);
+                });
+            });
+        }
+        repository.queryArray = queryArray;
+    })(repository = fluxApplication.repository || (fluxApplication.repository = {}));
+})(fluxApplication || (exports.fluxApplication = fluxApplication = {}));

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+import { IFluxObject } from './interfaces';
+export declare const FluxColumnPrimary: {
+    readonly String: "S";
+    readonly Number: "N";
+};
+export declare const FluxColumn: {
+    readonly String: "S";
+    readonly Number: "N";
+    readonly Boolean: "BOOL";
+    readonly Binary: "B";
+    readonly List: "L";
+    readonly Object: "M";
+};
+export type FluxColumnPrimary = typeof FluxColumnPrimary[keyof typeof FluxColumnPrimary];
+export type FluxColumn = typeof FluxColumn[keyof typeof FluxColumn];
+export type FluxDBFilterOperator = '=' | '<>' | 'EXISTS' | 'NOT EXISTS';
+export type FluxDBFilterOperatorValues = '<' | '<=' | '>' | '>=';
+export type FluxDBFilterOperatorCollection = 'IN';
+export type FluxDBFilterLogic = 'AND' | 'OR';
+export type FluxObjectCreator<T extends IFluxObject = IFluxObject> = new () => T;

package/dist/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluxColumn = exports.FluxColumnPrimary = void 0;
+exports.FluxColumnPrimary = {
+    String: 'S',
+    Number: 'N',
+};
+exports.FluxColumn = {
+    String: 'S',
+    Number: 'N',
+    Boolean: 'BOOL',
+    Binary: 'B',
+    List: 'L',
+    Object: 'M',
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@hapiboo/flux",
+  "version": "1.0.0",
+  "description": "MK13 Studio Hapiboo Flux - Modular Application Services",
+  "author": "MK13 Studio",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hapiboo/core": "^3.0.1",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "eslint": "^9.39.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0"
+  },
+  "scripts": {
+    "publish-check": "bash ../../scripts/publish.sh ./",
+    "ci:publish-prepare": "rm -f pnpm-lock.yaml && rm -rf node_modules dist && pnpm install --ignore-workspace --no-frozen-lockfile && eslint 'src/*.ts' && echo \"Linter OK\" && tsc && echo \"Build OK\"",
+    "ci:publish": "pnpm ci:publish-prepare && pnpm publish-check"
+  }
+}