@hazeljs/ml 0.2.0-alpha.1

package/dist/registry/model.registry.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_registry_1 = require("./model.registry");
+describe('ModelRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new model_registry_1.ModelRegistry();
+    });
+    it('registers and retrieves model by name and version', () => {
+        const model = {
+            metadata: { name: 'sentiment', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        };
+        registry.register(model);
+        const retrieved = registry.get('sentiment', '1.0.0');
+        expect(retrieved).toBe(model);
+    });
+    it('returns latest version when version not specified', () => {
+        const v1 = {
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        };
+        const v2 = {
+            metadata: { name: 'model', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        };
+        registry.register(v1);
+        registry.register(v2);
+        expect(registry.get('model')).toBe(v2);
+        expect(registry.get('model', '1.0.0')).toBe(v1);
+    });
+    it('returns undefined for unknown model', () => {
+        expect(registry.get('unknown')).toBeUndefined();
+        expect(registry.get('unknown', '1.0.0')).toBeUndefined();
+    });
+    it('lists all registered models', () => {
+        registry.register({
+            metadata: { name: 'a', version: '1', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'b', version: '1', framework: 'onnx' },
+            instance: {},
+        });
+        const list = registry.list();
+        expect(list).toHaveLength(2);
+        expect(list.map((m) => m.name)).toContain('a');
+        expect(list.map((m) => m.name)).toContain('b');
+    });
+    it('getVersions returns empty array for unknown model', () => {
+        expect(registry.getVersions('unknown')).toEqual([]);
+    });
+    it('getVersions returns version history', () => {
+        registry.register({
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'model', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        const versions = registry.getVersions('model');
+        expect(versions).toHaveLength(2);
+        expect(versions.map((v) => v.version)).toEqual(['1.0.0', '2.0.0']);
+    });
+    it('unregister removes model', () => {
+        registry.register({
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        expect(registry.get('model', '1.0.0')).toBeDefined();
+        const deleted = registry.unregister('model', '1.0.0');
+        expect(deleted).toBe(true);
+        expect(registry.get('model', '1.0.0')).toBeUndefined();
+        expect(registry.unregister('model', '1.0.0')).toBe(false);
+    });
+    it('unregister updates versions list when deleting', () => {
+        registry.register({
+            metadata: { name: 'm', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'm', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.unregister('m', '1.0.0');
+        const versions = registry.getVersions('m');
+        expect(versions).toHaveLength(1);
+        expect(versions[0].version).toBe('2.0.0');
+    });
+});

package/dist/training/pipeline.service.d.ts

@@ -0,0 +1,25 @@
+import { TrainingData } from '../ml.types';
+export interface PipelineStep {
+    name: string;
+    transform: (data: unknown) => Promise<unknown> | unknown;
+}
+/**
+ * Pipeline Service - ETL pipelines for training data preparation
+ * Handles data transformation before model training
+ */
+export declare class PipelineService {
+    private pipelines;
+    registerPipeline(name: string, steps: PipelineStep[]): void;
+    /**
+     * Run a registered pipeline by name.
+     */
+    run(name: string, data: TrainingData): Promise<TrainingData>;
+    /**
+     * Run an ad-hoc pipeline with inline steps (no registration required).
+     */
+    run(data: TrainingData, steps: PipelineStep[]): Promise<TrainingData>;
+    private executeSteps;
+    getPipeline(name: string): PipelineStep[] | undefined;
+    listPipelines(): string[];
+}
+//# sourceMappingURL=pipeline.service.d.ts.map

package/dist/training/pipeline.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.service.d.ts","sourceRoot":"","sources":["../../src/training/pipeline.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1D;AAED;;;GAGG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA0C;IAE3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAK3D;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAElE;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC;YA2B7D,YAAY;IAa1B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,SAAS;IAIrD,aAAa,IAAI,MAAM,EAAE;CAG1B"}

package/dist/training/pipeline.service.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Pipeline Service - ETL pipelines for training data preparation
+ * Handles data transformation before model training
+ */
+let PipelineService = class PipelineService {
+    constructor() {
+        this.pipelines = new Map();
+    }
+    registerPipeline(name, steps) {
+        this.pipelines.set(name, steps);
+        core_2.default.debug(`Registered pipeline: ${name} with ${steps.length} steps`);
+    }
+    async run(nameOrData, dataOrSteps) {
+        let data;
+        let steps;
+        let label;
+        if (typeof nameOrData === 'string') {
+            label = nameOrData;
+            data = dataOrSteps;
+            const registered = this.pipelines.get(nameOrData);
+            if (!registered) {
+                throw new Error(`Pipeline not found: ${nameOrData}`);
+            }
+            steps = registered;
+        }
+        else {
+            label = 'inline';
+            data = nameOrData;
+            steps = dataOrSteps;
+        }
+        return this.executeSteps(data, steps, label);
+    }
+    async executeSteps(data, steps, label) {
+        let result = data;
+        for (const step of steps) {
+            core_2.default.debug(`Pipeline ${label}: executing step ${step.name}`);
+            result = await Promise.resolve(step.transform(result));
+        }
+        return result;
+    }
+    getPipeline(name) {
+        return this.pipelines.get(name);
+    }
+    listPipelines() {
+        return Array.from(this.pipelines.keys());
+    }
+};
+exports.PipelineService = PipelineService;
+exports.PipelineService = PipelineService = __decorate([
+    (0, core_1.Service)()
+], PipelineService);

package/dist/training/pipeline.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipeline.service.test.d.ts.map

package/dist/training/pipeline.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.service.test.d.ts","sourceRoot":"","sources":["../../src/training/pipeline.service.test.ts"],"names":[],"mappings":""}

package/dist/training/pipeline.service.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_service_1 = require("./pipeline.service");
+describe('PipelineService', () => {
+    let service;
+    beforeEach(() => {
+        service = new pipeline_service_1.PipelineService();
+    });
+    it('registers and runs pipeline', async () => {
+        service.registerPipeline('test', [
+            { name: 'step1', transform: (d) => ({ ...d, a: 1 }) },
+            { name: 'step2', transform: (d) => ({ ...d, b: 2 }) },
+        ]);
+        const result = await service.run('test', { x: 0 });
+        expect(result).toEqual({ x: 0, a: 1, b: 2 });
+    });
+    it('handles async transforms', async () => {
+        service.registerPipeline('async', [
+            { name: 'async', transform: async (d) => ({ ...d, done: true }) },
+        ]);
+        const result = await service.run('async', {});
+        expect(result).toEqual({ done: true });
+    });
+    it('throws when pipeline not found', async () => {
+        await expect(service.run('missing', {})).rejects.toThrow('Pipeline not found: missing');
+    });
+    it('getPipeline returns steps', () => {
+        const steps = [{ name: 's1', transform: (d) => d }];
+        service.registerPipeline('p', steps);
+        expect(service.getPipeline('p')).toEqual(steps);
+        expect(service.getPipeline('x')).toBeUndefined();
+    });
+    it('listPipelines returns names', () => {
+        service.registerPipeline('a', []);
+        service.registerPipeline('b', []);
+        expect(service.listPipelines()).toEqual(['a', 'b']);
+    });
+    it('run with inline steps (no registration)', async () => {
+        const steps = [
+            {
+                name: 'lower',
+                transform: (d) => ({
+                    ...d,
+                    x: d.x?.toLowerCase() ?? '',
+                }),
+            },
+            { name: 'add', transform: (d) => ({ ...d, y: 1 }) },
+        ];
+        const result = await service.run({ x: 'HELLO' }, steps);
+        expect(result).toEqual({ x: 'hello', y: 1 });
+    });
+});

package/dist/training/trainer.service.d.ts

@@ -0,0 +1,13 @@
+import { ModelRegistry } from '../registry/model.registry';
+import { TrainingData, TrainingResult } from '../ml.types';
+/**
+ * Trainer Service - Training orchestration for ML models
+ * Coordinates training pipelines and model updates
+ */
+export declare class TrainerService {
+    private readonly modelRegistry;
+    constructor(modelRegistry: ModelRegistry);
+    train(modelName: string, data: TrainingData, version?: string): Promise<TrainingResult>;
+    discoverTrainMethod(instance: object): string | undefined;
+}
+//# sourceMappingURL=trainer.service.d.ts.map

package/dist/training/trainer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trainer.service.d.ts","sourceRoot":"","sources":["../../src/training/trainer.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG3D;;;GAGG;AACH,qBACa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEnD,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA2B7F,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAgB1D"}

package/dist/training/trainer.service.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainerService = void 0;
+const core_1 = require("@hazeljs/core");
+const model_registry_1 = require("../registry/model.registry");
+const decorators_1 = require("../decorators");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Trainer Service - Training orchestration for ML models
+ * Coordinates training pipelines and model updates
+ */
+let TrainerService = class TrainerService {
+    constructor(modelRegistry) {
+        this.modelRegistry = modelRegistry;
+    }
+    async train(modelName, data, version) {
+        const model = this.modelRegistry.get(modelName, version);
+        if (!model) {
+            throw new Error(`Model not found: ${modelName}`);
+        }
+        const trainMethod = model.trainMethod;
+        if (!trainMethod) {
+            throw new Error(`Model ${modelName} has no training method`);
+        }
+        const instance = model.instance;
+        const trainFn = instance[trainMethod];
+        if (typeof trainFn !== 'function') {
+            throw new Error(`Training method ${trainMethod} not found on model`);
+        }
+        core_2.default.debug(`Starting training for model: ${modelName}`);
+        const result = await trainFn.call(instance, data);
+        core_2.default.debug(`Training completed for model: ${modelName}`, result);
+        return result;
+    }
+    discoverTrainMethod(instance) {
+        const metadata = (0, decorators_1.getModelMetadata)(instance.constructor);
+        if (!metadata)
+            return undefined;
+        const proto = Object.getPrototypeOf(instance);
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key === 'constructor')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+            if (descriptor?.value && typeof descriptor.value === 'function') {
+                if ((0, decorators_1.getTrainMetadata)(proto, key)) {
+                    return key;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+exports.TrainerService = TrainerService;
+exports.TrainerService = TrainerService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry])
+], TrainerService);

package/dist/training/trainer.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trainer.service.test.d.ts.map

package/dist/training/trainer.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trainer.service.test.d.ts","sourceRoot":"","sources":["../../src/training/trainer.service.test.ts"],"names":[],"mappings":""}

package/dist/training/trainer.service.test.js

@@ -0,0 +1,99 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_registry_1 = require("../registry/model.registry");
+const trainer_service_1 = require("./trainer.service");
+const decorators_1 = require("../decorators");
+describe('TrainerService', () => {
+    let registry;
+    let trainer;
+    let TestModel = class TestModel {
+        async train(data) {
+            return { accuracy: 0.95, loss: 0.05, inputSize: data?.size };
+        }
+        async predict() {
+            return { value: 1 };
+        }
+    };
+    __decorate([
+        (0, decorators_1.Train)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "train", null);
+    __decorate([
+        (0, decorators_1.Predict)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "predict", null);
+    TestModel = __decorate([
+        (0, decorators_1.Model)({ name: 'test-model', version: '1.0.0', framework: 'tensorflow' })
+    ], TestModel);
+    beforeEach(() => {
+        registry = new model_registry_1.ModelRegistry();
+        trainer = new trainer_service_1.TrainerService(registry);
+        const instance = new TestModel();
+        registry.register({
+            metadata: { name: 'test-model', version: '1.0.0', framework: 'tensorflow' },
+            instance,
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        });
+    });
+    it('trains model and returns result', async () => {
+        const result = await trainer.train('test-model', { size: 100 });
+        expect(result).toEqual({ accuracy: 0.95, loss: 0.05, inputSize: 100 });
+    });
+    it('throws when model not found', async () => {
+        await expect(trainer.train('unknown', {})).rejects.toThrow('Model not found: unknown');
+    });
+    it('throws when model has no training method', async () => {
+        let NoTrainModel = class NoTrainModel {
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoTrainModel.prototype, "predict", null);
+        NoTrainModel = __decorate([
+            (0, decorators_1.Model)({ name: 'no-train', version: '1.0.0', framework: 'tensorflow' })
+        ], NoTrainModel);
+        registry.register({
+            metadata: { name: 'no-train', version: '1.0.0', framework: 'tensorflow' },
+            instance: new NoTrainModel(),
+            predictMethod: 'predict',
+        });
+        await expect(trainer.train('no-train', {})).rejects.toThrow('no-train has no training method');
+    });
+    it('discoverTrainMethod finds @Train decorated method', () => {
+        const instance = new TestModel();
+        expect(trainer.discoverTrainMethod(instance)).toBe('train');
+    });
+    it('discoverTrainMethod returns undefined for class without @Model', () => {
+        class PlainClass {
+            train() { }
+        }
+        expect(trainer.discoverTrainMethod(new PlainClass())).toBeUndefined();
+    });
+    it('throws when train method is not a function', async () => {
+        const fakeInstance = { train: 'not-a-function' };
+        registry.register({
+            metadata: { name: 'broken-train', version: '1.0.0', framework: 'custom' },
+            instance: fakeInstance,
+            trainMethod: 'train',
+            predictMethod: undefined,
+        });
+        await expect(trainer.train('broken-train', {})).rejects.toThrow('Training method train not found on model');
+    });
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hazeljs/ml",
+  "version": "0.2.0-alpha.1",
+  "description": "Machine Learning & Model Management for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --skipLibCheck",
+    "test": "jest --coverage --maxWorkers=1",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/ml"
+  },
+  "keywords": [
+    "hazeljs",
+    "ml",
+    "machine-learning",
+    "model-registry",
+    "tensorflow",
+    "onnx"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}