@hazeljs/ml 0.2.4 → 0.3.1

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

@@ -0,0 +1,167 @@
+"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 feature_decorator_1 = require("../feature.decorator");
+describe('Feature decorator', () => {
+    it('should attach metadata to property', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'number', description: 'Test feature' }),
+            __metadata("design:type", Number)
+        ], TestFeatures.prototype, "testFeature", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata).toBeDefined();
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].propertyKey).toBe('testFeature');
+        expect(metadata[0].valueType).toBe('number');
+        expect(metadata[0].description).toBe('Test feature');
+    });
+    it('should use property key as default name', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "myFeature", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].name).toBe('myFeature');
+    });
+    it('should use custom name when provided', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ name: 'custom_name', valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "myFeature", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].name).toBe('custom_name');
+    });
+    it('should support all value types', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "stringFeature", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'number' }),
+            __metadata("design:type", Number)
+        ], TestFeatures.prototype, "numberFeature", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'boolean' }),
+            __metadata("design:type", Boolean)
+        ], TestFeatures.prototype, "booleanFeature", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'array' }),
+            __metadata("design:type", Array)
+        ], TestFeatures.prototype, "arrayFeature", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'object' }),
+            __metadata("design:type", Object)
+        ], TestFeatures.prototype, "objectFeature", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata).toHaveLength(5);
+        expect(metadata[0].valueType).toBe('string');
+        expect(metadata[1].valueType).toBe('number');
+        expect(metadata[2].valueType).toBe('boolean');
+        expect(metadata[3].valueType).toBe('array');
+        expect(metadata[4].valueType).toBe('object');
+    });
+    it('should handle optional tags', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string', tags: ['demographic', 'pii'] }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "segment", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].tags).toEqual(['demographic', 'pii']);
+    });
+    it('should handle optional ttl', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'number', ttl: 3600 }),
+            __metadata("design:type", Number)
+        ], TestFeatures.prototype, "score", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].ttl).toBe(3600);
+    });
+    it('should handle optional entityExtractor', () => {
+        const extractor = (input) => String(input);
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string', entityExtractor: extractor }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "userId", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].entityExtractor).toBe(extractor);
+    });
+    it('should handle multiple features on same class', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "feature1", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'number' }),
+            __metadata("design:type", Number)
+        ], TestFeatures.prototype, "feature2", void 0);
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'boolean' }),
+            __metadata("design:type", Boolean)
+        ], TestFeatures.prototype, "feature3", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata).toHaveLength(3);
+        expect(metadata[0].propertyKey).toBe('feature1');
+        expect(metadata[1].propertyKey).toBe('feature2');
+        expect(metadata[2].propertyKey).toBe('feature3');
+    });
+    it('should handle features without optional fields', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "simpleFeature", void 0);
+        const metadata = (0, feature_decorator_1.getFeatureMetadata)(TestFeatures);
+        expect(metadata[0].description).toBeUndefined();
+        expect(metadata[0].tags).toBeUndefined();
+        expect(metadata[0].ttl).toBeUndefined();
+        expect(metadata[0].entityExtractor).toBeUndefined();
+    });
+});
+describe('hasFeatureMetadata', () => {
+    it('should return true for decorated class', () => {
+        class TestFeatures {
+        }
+        __decorate([
+            (0, feature_decorator_1.Feature)({ valueType: 'string' }),
+            __metadata("design:type", String)
+        ], TestFeatures.prototype, "feature", void 0);
+        expect((0, feature_decorator_1.hasFeatureMetadata)(TestFeatures)).toBe(true);
+    });
+    it('should return false for non-decorated class', () => {
+        class TestFeatures {
+        }
+        expect((0, feature_decorator_1.hasFeatureMetadata)(TestFeatures)).toBe(false);
+    });
+});
+describe('getFeatureMetadata', () => {
+    it('should return undefined for non-decorated class', () => {
+        class TestFeatures {
+        }
+        expect((0, feature_decorator_1.getFeatureMetadata)(TestFeatures)).toBeUndefined();
+    });
+});

package/dist/features/feature-store.service.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Feature Store Service - Central registry and retrieval for ML features
+ */
+import type { FeatureView, FeatureResponse, FeatureStoreConfig, FeatureMetadata } from './feature.types';
+export interface FeatureRegistration {
+    name: string;
+    view: FeatureView;
+    entityExtractor?: (input: unknown) => string;
+}
+export declare class FeatureStoreService {
+    private features;
+    private views;
+    private onlineStore;
+    private offlineStore;
+    private config;
+    configure(config: FeatureStoreConfig): void;
+    /**
+     * Register a feature view for discovery and retrieval
+     */
+    registerView(name: string, view: FeatureView): void;
+    /**
+     * Get features for online inference (low-latency)
+     */
+    getOnlineFeatures(entityIds: string[], featureNames: string[]): Promise<FeatureResponse[]>;
+    /**
+     * Get historical features for training (point-in-time correct)
+     */
+    getOfflineFeatures(entityIds: string[], featureNames: string[], timestamp: Date): Promise<FeatureResponse[]>;
+    /**
+     * Push features to online store (for real-time serving)
+     */
+    pushOnlineFeatures(entityId: string, features: Record<string, unknown>): Promise<void>;
+    /**
+     * Write features to offline store (for training data)
+     */
+    writeOfflineFeatures(entityId: string, features: Record<string, unknown>, timestamp?: Date): Promise<void>;
+    /**
+     * Materialize a feature view - compute and store features
+     */
+    materialize(viewName: string, entityIds: string[], options?: {
+        toOnline?: boolean;
+        toOffline?: boolean;
+    }): Promise<void>;
+    /**
+     * List all registered features
+     */
+    listFeatures(): FeatureMetadata[];
+    /**
+     * List all registered views
+     */
+    listViews(): string[];
+    /**
+     * Get a specific view
+     */
+    getView(name: string): FeatureView | undefined;
+    private groupByEntity;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=feature-store.service.d.ts.map

package/dist/features/feature-store.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-store.service.d.ts","sourceRoot":"","sources":["../../src/features/feature-store.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAEV,WAAW,EAEX,eAAe,EACf,kBAAkB,EAClB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAIzB,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAC9C;AAED,qBACa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAA2C;IAC3D,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,MAAM,CAA0B;IAExC,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAc3C;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI;IAkBnD;;OAEG;IACG,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAmBhG;;OAEG;IACG,kBAAkB,CACtB,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,IAAI,GACd,OAAO,CAAC,eAAe,EAAE,CAAC;IA2B7B;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB5F;;OAEG;IACG,oBAAoB,CACxB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,SAAS,GAAE,IAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC;IAehB;;OAEG;IACG,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO,GACxD,OAAO,CAAC,IAAI,CAAC;IA6BhB;;OAEG;IACH,YAAY,IAAI,eAAe,EAAE;IAIjC;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAIrB;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI9C,OAAO,CAAC,aAAa;IAaf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAS7B"}

package/dist/features/feature-store.service.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Feature Store Service - Central registry and retrieval for ML features
+ */
+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.FeatureStoreService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const online_store_1 = require("./online-store");
+const offline_store_1 = require("./offline-store");
+let FeatureStoreService = class FeatureStoreService {
+    constructor() {
+        this.features = new Map();
+        this.views = new Map();
+        this.onlineStore = null;
+        this.offlineStore = null;
+        this.config = {};
+    }
+    configure(config) {
+        this.config = config;
+        if (config.online) {
+            this.onlineStore = (0, online_store_1.createOnlineStore)(config.online);
+            core_2.default.debug('FeatureStore: online store configured', { type: config.online.type });
+        }
+        if (config.offline) {
+            this.offlineStore = (0, offline_store_1.createOfflineStore)(config.offline);
+            core_2.default.debug('FeatureStore: offline store configured', { type: config.offline.type });
+        }
+    }
+    /**
+     * Register a feature view for discovery and retrieval
+     */
+    registerView(name, view) {
+        this.views.set(name, view);
+        // Register individual features
+        for (const feature of view.features) {
+            this.features.set(feature.name, {
+                name: feature.name,
+                description: feature.description,
+                valueType: feature.valueType,
+                tags: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        core_2.default.debug(`Registered feature view: ${name} with ${view.features.length} features`);
+    }
+    /**
+     * Get features for online inference (low-latency)
+     */
+    async getOnlineFeatures(entityIds, featureNames) {
+        if (!this.onlineStore) {
+            throw new Error('Online store not configured. Call configure() first.');
+        }
+        const responses = [];
+        for (const entityId of entityIds) {
+            const features = await this.onlineStore.getMulti(entityId, featureNames);
+            responses.push({
+                entityId,
+                features,
+                timestamp: new Date(),
+            });
+        }
+        return responses;
+    }
+    /**
+     * Get historical features for training (point-in-time correct)
+     */
+    async getOfflineFeatures(entityIds, featureNames, timestamp) {
+        if (!this.offlineStore) {
+            throw new Error('Offline store not configured. Call configure() first.');
+        }
+        if (!this.config.enablePointInTime) {
+            // Simple read without point-in-time correction
+            const values = await this.offlineStore.read(entityIds, featureNames);
+            const grouped = this.groupByEntity(values);
+            return entityIds.map((entityId) => ({
+                entityId,
+                features: grouped[entityId] ?? {},
+                timestamp,
+            }));
+        }
+        // Point-in-time correct retrieval (prevents data leakage)
+        const pitFeatures = await this.offlineStore.readPointInTime(entityIds, featureNames, timestamp);
+        return entityIds.map((entityId) => ({
+            entityId,
+            features: pitFeatures[entityId] ?? {},
+            timestamp,
+        }));
+    }
+    /**
+     * Push features to online store (for real-time serving)
+     */
+    async pushOnlineFeatures(entityId, features) {
+        if (!this.onlineStore) {
+            throw new Error('Online store not configured');
+        }
+        const now = new Date();
+        const values = Object.entries(features).map(([name, value]) => ({
+            entityId,
+            featureName: name,
+            value,
+            timestamp: now,
+        }));
+        await this.onlineStore.setMulti(values);
+    }
+    /**
+     * Write features to offline store (for training data)
+     */
+    async writeOfflineFeatures(entityId, features, timestamp = new Date()) {
+        if (!this.offlineStore) {
+            throw new Error('Offline store not configured');
+        }
+        const values = Object.entries(features).map(([name, value]) => ({
+            entityId,
+            featureName: name,
+            value,
+            timestamp,
+        }));
+        await this.offlineStore.write(values);
+    }
+    /**
+     * Materialize a feature view - compute and store features
+     */
+    async materialize(viewName, entityIds, options = {}) {
+        const view = this.views.get(viewName);
+        if (!view) {
+            throw new Error(`Feature view not found: ${viewName}`);
+        }
+        const _featureNames = view.features.map((f) => f.name);
+        for (const entityId of entityIds) {
+            const features = {};
+            for (const feature of view.features) {
+                if (feature.transform) {
+                    features[feature.name] = feature.transform({ entityId });
+                }
+            }
+            if (options.toOnline && this.onlineStore) {
+                await this.pushOnlineFeatures(entityId, features);
+            }
+            if (options.toOffline && this.offlineStore) {
+                await this.writeOfflineFeatures(entityId, features);
+            }
+        }
+        core_2.default.debug(`Materialized ${viewName} for ${entityIds.length} entities`);
+    }
+    /**
+     * List all registered features
+     */
+    listFeatures() {
+        return Array.from(this.features.values());
+    }
+    /**
+     * List all registered views
+     */
+    listViews() {
+        return Array.from(this.views.keys());
+    }
+    /**
+     * Get a specific view
+     */
+    getView(name) {
+        return this.views.get(name);
+    }
+    groupByEntity(values) {
+        const grouped = {};
+        for (const v of values) {
+            if (!grouped[v.entityId]) {
+                grouped[v.entityId] = {};
+            }
+            grouped[v.entityId][v.featureName] = v.value;
+        }
+        return grouped;
+    }
+    async close() {
+        if (this.onlineStore) {
+            await this.onlineStore.close();
+        }
+        if (this.offlineStore) {
+            await this.offlineStore.close();
+        }
+        core_2.default.debug('FeatureStore: closed all stores');
+    }
+};
+exports.FeatureStoreService = FeatureStoreService;
+exports.FeatureStoreService = FeatureStoreService = __decorate([
+    (0, core_1.Service)()
+], FeatureStoreService);

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

@@ -0,0 +1,52 @@
+/**
+ * @FeatureView decorator - Define a collection of related features
+ */
+import 'reflect-metadata';
+export declare const FEATURE_VIEW_METADATA_KEY: unique symbol;
+export interface FeatureViewOptions {
+    name: string;
+    description?: string;
+    entities: string[];
+    online?: boolean;
+    offline?: boolean;
+    ttl?: number;
+    source?: {
+        type: 'batch' | 'stream' | 'request';
+        config?: Record<string, unknown>;
+    };
+}
+export interface FeatureViewMetadata {
+    name: string;
+    description?: string;
+    entities: string[];
+    online: boolean;
+    offline: boolean;
+    ttl?: number;
+    source?: FeatureViewOptions['source'];
+}
+/**
+ * Mark a class as a Feature View - a collection of related features.
+ * Combine with @Feature on properties to define the feature schema.
+ *
+ * @example
+ * ```typescript
+ * @FeatureView({
+ *   name: 'user-behavior',
+ *   entities: ['user'],
+ *   description: 'Features derived from user behavior',
+ *   online: true,
+ *   offline: true
+ * })
+ * class UserBehaviorFeatures {
+ *   @Feature({ valueType: 'number' })
+ *   loginCount: number;
+ *
+ *   @Feature({ valueType: 'number' })
+ *   avgSessionDuration: number;
+ * }
+ * ```
+ */
+export declare function FeatureView(options: FeatureViewOptions): ClassDecorator;
+export declare function getFeatureViewMetadata(target: object): FeatureViewMetadata | undefined;
+export declare function hasFeatureViewMetadata(target: object): boolean;
+//# sourceMappingURL=feature-view.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-view.decorator.d.ts","sourceRoot":"","sources":["../../src/features/feature-view.decorator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,yBAAyB,eAAwC,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;QACrC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,cAAc,CAevE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAEtF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D"}

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

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * @FeatureView decorator - Define a collection of related features
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURE_VIEW_METADATA_KEY = void 0;
+exports.FeatureView = FeatureView;
+exports.getFeatureViewMetadata = getFeatureViewMetadata;
+exports.hasFeatureViewMetadata = hasFeatureViewMetadata;
+require("reflect-metadata");
+exports.FEATURE_VIEW_METADATA_KEY = Symbol('hazel:feature-view:metadata');
+/**
+ * Mark a class as a Feature View - a collection of related features.
+ * Combine with @Feature on properties to define the feature schema.
+ *
+ * @example
+ * ```typescript
+ * @FeatureView({
+ *   name: 'user-behavior',
+ *   entities: ['user'],
+ *   description: 'Features derived from user behavior',
+ *   online: true,
+ *   offline: true
+ * })
+ * class UserBehaviorFeatures {
+ *   @Feature({ valueType: 'number' })
+ *   loginCount: number;
+ *
+ *   @Feature({ valueType: 'number' })
+ *   avgSessionDuration: number;
+ * }
+ * ```
+ */
+function FeatureView(options) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return function (target) {
+        const metadata = {
+            name: options.name,
+            description: options.description,
+            entities: options.entities,
+            online: options.online ?? true,
+            offline: options.offline ?? true,
+            ttl: options.ttl,
+            source: options.source,
+        };
+        Reflect.defineMetadata(exports.FEATURE_VIEW_METADATA_KEY, metadata, target);
+    };
+}
+function getFeatureViewMetadata(target) {
+    return Reflect.getMetadata(exports.FEATURE_VIEW_METADATA_KEY, target);
+}
+function hasFeatureViewMetadata(target) {
+    return Reflect.hasMetadata(exports.FEATURE_VIEW_METADATA_KEY, target);
+}

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

@@ -0,0 +1,42 @@
+/**
+ * @Feature decorator - Mark a class property as a feature
+ */
+import 'reflect-metadata';
+export declare const FEATURE_METADATA_KEY: unique symbol;
+export interface FeatureOptions {
+    name?: string;
+    description?: string;
+    valueType: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    tags?: string[];
+    ttl?: number;
+    entityExtractor?: (input: unknown) => string;
+}
+export interface FeatureMetadata {
+    propertyKey: string;
+    name: string;
+    description?: string;
+    valueType: FeatureOptions['valueType'];
+    tags?: string[];
+    ttl?: number;
+    entityExtractor?: (input: unknown) => string;
+}
+/**
+ * Mark a class property as a feature for the Feature Store.
+ * The property will be automatically discovered and registered.
+ *
+ * @example
+ * ```typescript
+ * @FeatureView({ name: 'user-features', entities: ['user'] })
+ * class UserFeatures {
+ *   @Feature({ valueType: 'number', description: 'User purchase count' })
+ *   purchaseCount: number;
+ *
+ *   @Feature({ valueType: 'string', tags: ['demographic'] })
+ *   segment: string;
+ * }
+ * ```
+ */
+export declare function Feature(options: FeatureOptions): PropertyDecorator;
+export declare function getFeatureMetadata(target: object): FeatureMetadata[] | undefined;
+export declare function hasFeatureMetadata(target: object): boolean;
+//# sourceMappingURL=feature.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.decorator.d.ts","sourceRoot":"","sources":["../../src/features/feature.decorator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,oBAAoB,eAAmC,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;IAChE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAC9C;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAgBlE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,GAAG,SAAS,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/features/feature.decorator.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * @Feature decorator - Mark a class property as a feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURE_METADATA_KEY = void 0;
+exports.Feature = Feature;
+exports.getFeatureMetadata = getFeatureMetadata;
+exports.hasFeatureMetadata = hasFeatureMetadata;
+require("reflect-metadata");
+exports.FEATURE_METADATA_KEY = Symbol('hazel:feature:metadata');
+/**
+ * Mark a class property as a feature for the Feature Store.
+ * The property will be automatically discovered and registered.
+ *
+ * @example
+ * ```typescript
+ * @FeatureView({ name: 'user-features', entities: ['user'] })
+ * class UserFeatures {
+ *   @Feature({ valueType: 'number', description: 'User purchase count' })
+ *   purchaseCount: number;
+ *
+ *   @Feature({ valueType: 'string', tags: ['demographic'] })
+ *   segment: string;
+ * }
+ * ```
+ */
+function Feature(options) {
+    return function (target, propertyKey) {
+        const metadata = {
+            propertyKey: propertyKey,
+            name: options.name ?? propertyKey,
+            description: options.description,
+            valueType: options.valueType,
+            tags: options.tags,
+            ttl: options.ttl,
+            entityExtractor: options.entityExtractor,
+        };
+        const existing = Reflect.getMetadata(exports.FEATURE_METADATA_KEY, target.constructor) || [];
+        existing.push(metadata);
+        Reflect.defineMetadata(exports.FEATURE_METADATA_KEY, existing, target.constructor);
+    };
+}
+function getFeatureMetadata(target) {
+    return Reflect.getMetadata(exports.FEATURE_METADATA_KEY, target);
+}
+function hasFeatureMetadata(target) {
+    return Reflect.hasMetadata(exports.FEATURE_METADATA_KEY, target);
+}