@hazeljs/ml 0.2.4 → 0.3.1

package/dist/experiments/experiment.service.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Experiment Service - ML experiment tracking and management
+ */
+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.ExperimentService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+let ExperimentService = class ExperimentService {
+    constructor() {
+        this.experiments = new Map();
+        this.runs = new Map();
+        this.config = { storage: 'memory' };
+        this.storageDir = './experiments';
+    }
+    configure(config) {
+        this.config = config;
+        if (config.file) {
+            this.storageDir = config.file.directory;
+        }
+        core_2.default.debug('ExperimentService configured', { storage: config.storage });
+    }
+    // ─── Experiments ───────────────────────────────────────────────────────────
+    createExperiment(name, options = {}) {
+        const experiment = {
+            id: generateId(),
+            name,
+            description: options.description,
+            tags: options.tags,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.experiments.set(experiment.id, experiment);
+        if (this.config.storage === 'file') {
+            this.saveExperimentToFile(experiment);
+        }
+        core_2.default.debug(`Created experiment: ${name} (${experiment.id})`);
+        return experiment;
+    }
+    getExperiment(id) {
+        if (this.config.storage === 'file') {
+            return this.loadExperimentFromFile(id);
+        }
+        return this.experiments.get(id);
+    }
+    listExperiments() {
+        if (this.config.storage === 'file') {
+            return this.loadAllExperimentsFromFile();
+        }
+        return Array.from(this.experiments.values());
+    }
+    deleteExperiment(id) {
+        // Delete associated runs first
+        const runsToDelete = Array.from(this.runs.values()).filter((r) => r.experimentId === id);
+        for (const run of runsToDelete) {
+            this.deleteRun(run.id);
+        }
+        const deleted = this.experiments.delete(id);
+        if (deleted && this.config.storage === 'file') {
+            const expDir = (0, path_1.join)(this.storageDir, id);
+            if ((0, fs_1.existsSync)(expDir)) {
+                // Delete all files in experiment directory
+                const files = (0, fs_1.readdirSync)(expDir);
+                for (const file of files) {
+                    (0, fs_1.unlinkSync)((0, path_1.join)(expDir, file));
+                }
+            }
+        }
+        core_2.default.debug(`Deleted experiment: ${id}`);
+        return deleted;
+    }
+    // ─── Runs ──────────────────────────────────────────────────────────────────
+    startRun(experimentId, options = {}) {
+        const run = {
+            id: generateId(),
+            experimentId,
+            name: options.name,
+            status: 'running',
+            params: options.params ?? {},
+            metrics: {},
+            artifacts: [],
+            startTime: new Date(),
+            tags: options.tags,
+        };
+        this.runs.set(run.id, run);
+        if (this.config.storage === 'file') {
+            this.saveRunToFile(run);
+        }
+        core_2.default.debug(`Started run: ${run.id} for experiment: ${experimentId}`);
+        return run;
+    }
+    endRun(runId, status = 'completed') {
+        const run = this.runs.get(runId);
+        if (!run) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+        run.status = status;
+        run.endTime = new Date();
+        run.durationMs = run.endTime.getTime() - run.startTime.getTime();
+        if (this.config.storage === 'file') {
+            this.saveRunToFile(run);
+        }
+        core_2.default.debug(`Ended run: ${runId} with status: ${status}`);
+        return run;
+    }
+    getRun(id) {
+        if (this.config.storage === 'file') {
+            return this.loadRunFromFile(id);
+        }
+        return this.runs.get(id);
+    }
+    listRuns(experimentId) {
+        if (this.config.storage === 'file') {
+            const all = this.loadAllRunsFromFile();
+            if (experimentId) {
+                return all.filter((r) => r.experimentId === experimentId);
+            }
+            return all;
+        }
+        const runs = Array.from(this.runs.values());
+        if (experimentId) {
+            return runs.filter((r) => r.experimentId === experimentId);
+        }
+        return runs;
+    }
+    deleteRun(id) {
+        const run = this.runs.get(id);
+        if (!run)
+            return false;
+        // Delete artifacts
+        for (const artifact of run.artifacts) {
+            this.deleteArtifactFile(artifact);
+        }
+        const deleted = this.runs.delete(id);
+        if (deleted && this.config.storage === 'file') {
+            const runPath = (0, path_1.join)(this.storageDir, run.experimentId, `run-${id}.json`);
+            if ((0, fs_1.existsSync)(runPath)) {
+                (0, fs_1.unlinkSync)(runPath);
+            }
+        }
+        return deleted;
+    }
+    // ─── Metrics ───────────────────────────────────────────────────────────────
+    logMetric(runId, key, value) {
+        const run = this.runs.get(runId);
+        if (!run) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+        run.metrics[key] = value;
+        if (this.config.storage === 'file') {
+            this.saveRunToFile(run);
+        }
+        core_2.default.debug(`Logged metric: ${key}=${value} for run: ${runId}`);
+    }
+    logMetrics(runId, metrics) {
+        for (const [key, value] of Object.entries(metrics)) {
+            this.logMetric(runId, key, value);
+        }
+    }
+    getBestRun(experimentId, metric, mode = 'max') {
+        const runs = this.listRuns(experimentId).filter((r) => r.metrics[metric] !== undefined);
+        if (runs.length === 0)
+            return undefined;
+        return runs.reduce((best, current) => {
+            const bestValue = best.metrics[metric];
+            const currentValue = current.metrics[metric];
+            if (mode === 'max') {
+                return currentValue > bestValue ? current : best;
+            }
+            else {
+                return currentValue < bestValue ? current : best;
+            }
+        });
+    }
+    // ─── Artifacts ───────────────────────────────────────────────────────────────
+    logArtifact(runId, name, type, content, metadata) {
+        const run = this.runs.get(runId);
+        if (!run) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+        const artifact = {
+            id: generateId(),
+            runId,
+            name,
+            type,
+            path: '', // Will be set based on storage
+            size: Buffer.byteLength(content),
+            metadata,
+            createdAt: new Date(),
+        };
+        if (this.config.storage === 'file') {
+            const artifactPath = (0, path_1.join)(this.storageDir, run.experimentId, runId, `${name}.${this.getArtifactExtension(type)}`);
+            artifact.path = artifactPath;
+            // Ensure directory exists
+            const dir = (0, path_1.join)(this.storageDir, run.experimentId, runId);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(artifactPath, content);
+        }
+        else {
+            // In-memory: store content in metadata (not ideal for large files)
+            artifact.path = `memory://${artifact.id}`;
+            artifact.metadata = { ...artifact.metadata, _content: content.toString('base64') };
+        }
+        run.artifacts.push(artifact);
+        if (this.config.storage === 'file') {
+            this.saveRunToFile(run);
+        }
+        core_2.default.debug(`Logged artifact: ${name} for run: ${runId}`);
+        return artifact;
+    }
+    getArtifact(runId, artifactId) {
+        const run = this.runs.get(runId);
+        if (!run)
+            return undefined;
+        return run.artifacts.find((a) => a.id === artifactId);
+    }
+    // ─── Comparison ─────────────────────────────────────────────────────────────
+    compareRuns(runIds) {
+        return runIds
+            .map((id) => this.getRun(id))
+            .filter((run) => run !== undefined && run.status === 'completed')
+            .map((run) => ({
+            runId: run.id,
+            params: run.params,
+            metrics: run.metrics,
+            durationMs: run.durationMs ?? 0,
+        }));
+    }
+    // ─── File Storage Helpers ────────────────────────────────────────────────────
+    saveExperimentToFile(experiment) {
+        const expDir = (0, path_1.join)(this.storageDir, experiment.id);
+        if (!(0, fs_1.existsSync)(expDir)) {
+            (0, fs_1.mkdirSync)(expDir, { recursive: true });
+        }
+        const path = (0, path_1.join)(expDir, 'experiment.json');
+        (0, fs_1.writeFileSync)(path, JSON.stringify(experiment, null, 2));
+    }
+    loadExperimentFromFile(id) {
+        const path = (0, path_1.join)(this.storageDir, id, 'experiment.json');
+        if (!(0, fs_1.existsSync)(path))
+            return undefined;
+        const content = (0, fs_1.readFileSync)(path, 'utf-8');
+        const exp = JSON.parse(content);
+        exp.createdAt = new Date(exp.createdAt);
+        exp.updatedAt = new Date(exp.updatedAt);
+        return exp;
+    }
+    loadAllExperimentsFromFile() {
+        if (!(0, fs_1.existsSync)(this.storageDir))
+            return [];
+        const experiments = [];
+        const dirs = (0, fs_1.readdirSync)(this.storageDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (dir.isDirectory()) {
+                const exp = this.loadExperimentFromFile(dir.name);
+                if (exp)
+                    experiments.push(exp);
+            }
+        }
+        return experiments;
+    }
+    saveRunToFile(run) {
+        const expDir = (0, path_1.join)(this.storageDir, run.experimentId);
+        if (!(0, fs_1.existsSync)(expDir)) {
+            (0, fs_1.mkdirSync)(expDir, { recursive: true });
+        }
+        const path = (0, path_1.join)(expDir, `run-${run.id}.json`);
+        (0, fs_1.writeFileSync)(path, JSON.stringify(run, null, 2));
+    }
+    loadRunFromFile(id) {
+        // Find the run file in any experiment directory
+        if (!(0, fs_1.existsSync)(this.storageDir))
+            return undefined;
+        const dirs = (0, fs_1.readdirSync)(this.storageDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (dir.isDirectory()) {
+                const path = (0, path_1.join)(this.storageDir, dir.name, `run-${id}.json`);
+                if ((0, fs_1.existsSync)(path)) {
+                    const content = (0, fs_1.readFileSync)(path, 'utf-8');
+                    const run = JSON.parse(content);
+                    run.startTime = new Date(run.startTime);
+                    if (run.endTime)
+                        run.endTime = new Date(run.endTime);
+                    for (const artifact of run.artifacts) {
+                        artifact.createdAt = new Date(artifact.createdAt);
+                    }
+                    return run;
+                }
+            }
+        }
+        return undefined;
+    }
+    loadAllRunsFromFile() {
+        if (!(0, fs_1.existsSync)(this.storageDir))
+            return [];
+        const runs = [];
+        const dirs = (0, fs_1.readdirSync)(this.storageDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (dir.isDirectory()) {
+                const expDir = (0, path_1.join)(this.storageDir, dir.name);
+                const files = (0, fs_1.readdirSync)(expDir);
+                for (const file of files) {
+                    if (file.startsWith('run-') && file.endsWith('.json')) {
+                        const runId = file.replace('run-', '').replace('.json', '');
+                        const run = this.loadRunFromFile(runId);
+                        if (run)
+                            runs.push(run);
+                    }
+                }
+            }
+        }
+        return runs;
+    }
+    deleteArtifactFile(artifact) {
+        if (artifact.path.startsWith('file://') || !artifact.path.startsWith('memory://')) {
+            if ((0, fs_1.existsSync)(artifact.path)) {
+                (0, fs_1.unlinkSync)(artifact.path);
+            }
+        }
+    }
+    getArtifactExtension(type) {
+        switch (type) {
+            case 'model':
+                return 'bin';
+            case 'plot':
+                return 'png';
+            case 'log':
+                return 'log';
+            case 'data':
+                return 'json';
+            default:
+                return 'txt';
+        }
+    }
+};
+exports.ExperimentService = ExperimentService;
+exports.ExperimentService = ExperimentService = __decorate([
+    (0, core_1.Service)()
+], ExperimentService);

package/dist/experiments/experiment.types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @hazeljs/ml - Experiment Tracking Types
+ */
+export interface Experiment {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Run {
+    id: string;
+    experimentId: string;
+    name?: string;
+    status: 'running' | 'completed' | 'failed' | 'aborted';
+    params: Record<string, unknown>;
+    metrics: Record<string, number>;
+    artifacts: Artifact[];
+    startTime: Date;
+    endTime?: Date;
+    durationMs?: number;
+    tags?: string[];
+}
+export interface Artifact {
+    id: string;
+    runId: string;
+    name: string;
+    type: 'model' | 'plot' | 'log' | 'data' | 'other';
+    path: string;
+    size?: number;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface ExperimentConfig {
+    storage: 'file' | 'postgres' | 'memory';
+    file?: {
+        directory: string;
+    };
+    postgres?: {
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        password: string;
+    };
+}
+export interface ExperimentQuery {
+    name?: string;
+    tags?: string[];
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+export interface RunComparison {
+    runId: string;
+    params: Record<string, unknown>;
+    metrics: Record<string, number>;
+    durationMs: number;
+}
+//# sourceMappingURL=experiment.types.d.ts.map

package/dist/experiments/experiment.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiment.types.d.ts","sourceRoot":"","sources":["../../src/experiments/experiment.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IACvD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IACxC,IAAI,CAAC,EAAE;QACL,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,aAAa,CAAC,EAAE,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/experiments/experiment.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @hazeljs/ml - Experiment Tracking Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/experiments/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @hazeljs/ml - Experiment Tracking
+ *
+ * Export all experiment tracking components
+ */
+export type { Experiment as ExperimentType, Run, Artifact, ExperimentConfig, ExperimentQuery, RunComparison, } from './experiment.types';
+export { ExperimentService } from './experiment.service';
+export { Experiment, getExperimentMetadata, hasExperimentMetadata, type ExperimentOptions, type ExperimentMetadata, } from './experiment.decorator';
+//# sourceMappingURL=index.d.ts.map

package/dist/experiments/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/experiments/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,UAAU,IAAI,cAAc,EAC5B,GAAG,EACH,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,aAAa,GACd,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EACL,UAAU,EACV,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,GACxB,MAAM,wBAAwB,CAAC"}

package/dist/experiments/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @hazeljs/ml - Experiment Tracking
+ *
+ * Export all experiment tracking components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasExperimentMetadata = exports.getExperimentMetadata = exports.Experiment = exports.ExperimentService = void 0;
+// Services
+var experiment_service_1 = require("./experiment.service");
+Object.defineProperty(exports, "ExperimentService", { enumerable: true, get: function () { return experiment_service_1.ExperimentService; } });
+// Decorators
+var experiment_decorator_1 = require("./experiment.decorator");
+Object.defineProperty(exports, "Experiment", { enumerable: true, get: function () { return experiment_decorator_1.Experiment; } });
+Object.defineProperty(exports, "getExperimentMetadata", { enumerable: true, get: function () { return experiment_decorator_1.getExperimentMetadata; } });
+Object.defineProperty(exports, "hasExperimentMetadata", { enumerable: true, get: function () { return experiment_decorator_1.hasExperimentMetadata; } });

package/dist/features/__tests__/feature-view.decorator.test.d.ts

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

package/dist/features/__tests__/feature-view.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-view.decorator.test.d.ts","sourceRoot":"","sources":["../../../src/features/__tests__/feature-view.decorator.test.ts"],"names":[],"mappings":""}

package/dist/features/__tests__/feature-view.decorator.test.js

@@ -0,0 +1,168 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const feature_view_decorator_1 = require("../feature-view.decorator");
+describe('FeatureView decorator', () => {
+    it('should attach metadata to class', () => {
+        let UserFeatures = class UserFeatures {
+        };
+        UserFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({
+                name: 'user-features',
+                entities: ['user'],
+                description: 'User feature view',
+            })
+        ], UserFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(UserFeatures);
+        expect(metadata).toBeDefined();
+        expect(metadata?.name).toBe('user-features');
+        expect(metadata?.entities).toEqual(['user']);
+        expect(metadata?.description).toBe('User feature view');
+    });
+    it('should default online to true', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'] })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.online).toBe(true);
+    });
+    it('should default offline to true', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'] })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.offline).toBe(true);
+    });
+    it('should allow setting online to false', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'], online: false })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.online).toBe(false);
+    });
+    it('should allow setting offline to false', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'], offline: false })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.offline).toBe(false);
+    });
+    it('should handle multiple entities', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user', 'product', 'session'] })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.entities).toEqual(['user', 'product', 'session']);
+    });
+    it('should handle optional ttl', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'], ttl: 3600 })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.ttl).toBe(3600);
+    });
+    it('should handle batch source', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({
+                name: 'test',
+                entities: ['user'],
+                source: { type: 'batch', config: { path: '/data/features' } },
+            })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.source?.type).toBe('batch');
+        expect(metadata?.source?.config).toEqual({ path: '/data/features' });
+    });
+    it('should handle stream source', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({
+                name: 'test',
+                entities: ['user'],
+                source: { type: 'stream', config: { topic: 'features' } },
+            })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.source?.type).toBe('stream');
+    });
+    it('should handle request source', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({
+                name: 'test',
+                entities: ['user'],
+                source: { type: 'request' },
+            })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.source?.type).toBe('request');
+    });
+    it('should handle source without config', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({
+                name: 'test',
+                entities: ['user'],
+                source: { type: 'batch' },
+            })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.source?.type).toBe('batch');
+        expect(metadata?.source?.config).toBeUndefined();
+    });
+    it('should handle features without optional fields', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'] })
+        ], TestFeatures);
+        const metadata = (0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures);
+        expect(metadata?.description).toBeUndefined();
+        expect(metadata?.ttl).toBeUndefined();
+        expect(metadata?.source).toBeUndefined();
+    });
+});
+describe('hasFeatureViewMetadata', () => {
+    it('should return true for decorated class', () => {
+        let TestFeatures = class TestFeatures {
+        };
+        TestFeatures = __decorate([
+            (0, feature_view_decorator_1.FeatureView)({ name: 'test', entities: ['user'] })
+        ], TestFeatures);
+        expect((0, feature_view_decorator_1.hasFeatureViewMetadata)(TestFeatures)).toBe(true);
+    });
+    it('should return false for non-decorated class', () => {
+        class TestFeatures {
+        }
+        expect((0, feature_view_decorator_1.hasFeatureViewMetadata)(TestFeatures)).toBe(false);
+    });
+});
+describe('getFeatureViewMetadata', () => {
+    it('should return undefined for non-decorated class', () => {
+        class TestFeatures {
+        }
+        expect((0, feature_view_decorator_1.getFeatureViewMetadata)(TestFeatures)).toBeUndefined();
+    });
+});

package/dist/features/__tests__/feature.decorator.test.d.ts

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

package/dist/features/__tests__/feature.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.decorator.test.d.ts","sourceRoot":"","sources":["../../../src/features/__tests__/feature.decorator.test.ts"],"names":[],"mappings":""}