@hazeljs/data 0.2.3 → 0.3.0

package/dist/contracts/__tests__/contract.decorator.test.d.ts

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

package/dist/contracts/__tests__/contract.decorator.test.d.ts.map

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

package/dist/contracts/__tests__/contract.decorator.test.js

@@ -0,0 +1,177 @@
+"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 contract_decorator_1 = require("../contract.decorator");
+describe('DataContract decorator', () => {
+    it('should attach metadata to class', () => {
+        let TestContract = class TestContract {
+        };
+        TestContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'test-contract',
+                version: '1.0.0',
+                description: 'Test contract',
+                owner: 'data-team',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        name: { type: 'string' },
+                    },
+                },
+            })
+        ], TestContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(TestContract);
+        expect(metadata).toBeDefined();
+        expect(metadata?.name).toBe('test-contract');
+        expect(metadata?.version).toBe('1.0.0');
+        expect(metadata?.description).toBe('Test contract');
+        expect(metadata?.owner).toBe('data-team');
+        expect(metadata?.status).toBe('active');
+        expect(metadata?.createdAt).toBeInstanceOf(Date);
+        expect(metadata?.updatedAt).toBeInstanceOf(Date);
+    });
+    it('should handle optional fields', () => {
+        let MinimalContract = class MinimalContract {
+        };
+        MinimalContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'minimal-contract',
+                version: '1.0.0',
+                owner: 'team-a',
+                schema: {
+                    type: 'object',
+                    properties: {},
+                },
+            })
+        ], MinimalContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(MinimalContract);
+        expect(metadata).toBeDefined();
+        expect(metadata?.name).toBe('minimal-contract');
+        expect(metadata?.description).toBeUndefined();
+    });
+    it('should handle consumers and producers', () => {
+        let ConsumedContract = class ConsumedContract {
+        };
+        ConsumedContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'consumed-contract',
+                version: '1.0.0',
+                owner: 'data-platform',
+                schema: { type: 'object', properties: {} },
+                consumers: ['service-a', 'service-b'],
+                producers: ['producer-1'],
+            })
+        ], ConsumedContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(ConsumedContract);
+        expect(metadata?.consumers).toEqual(['service-a', 'service-b']);
+        expect(metadata?.producers).toEqual(['producer-1']);
+    });
+    it('should handle SLA configuration', () => {
+        let SLAContract = class SLAContract {
+        };
+        SLAContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'sla-contract',
+                version: '1.0.0',
+                owner: 'analytics-team',
+                schema: { type: 'object', properties: {} },
+                sla: {
+                    freshness: {
+                        maxDelayMinutes: 60,
+                        checkIntervalMinutes: 15,
+                    },
+                    completeness: {
+                        minCompleteness: 0.95,
+                        requiredFields: ['id', 'timestamp'],
+                    },
+                    quality: {
+                        minQualityScore: 0.9,
+                        checks: ['no-nulls', 'valid-format'],
+                    },
+                    availability: {
+                        minUptime: 0.99,
+                    },
+                },
+            })
+        ], SLAContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(SLAContract);
+        expect(metadata?.sla?.freshness?.maxDelayMinutes).toBe(60);
+        expect(metadata?.sla?.completeness?.minCompleteness).toBe(0.95);
+        expect(metadata?.sla?.quality?.minQualityScore).toBe(0.9);
+        expect(metadata?.sla?.availability?.minUptime).toBe(0.99);
+    });
+    it('should return undefined for non-decorated class', () => {
+        class NotDecorated {
+        }
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(NotDecorated);
+        expect(metadata).toBeUndefined();
+    });
+    it('should handle complex schema', () => {
+        let ComplexContract = class ComplexContract {
+        };
+        ComplexContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'complex-contract',
+                version: '2.0.0',
+                owner: 'ml-team',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        metadata: {
+                            type: 'object',
+                            properties: {
+                                tags: { type: 'array', items: { type: 'string' } },
+                            },
+                        },
+                    },
+                    required: ['id'],
+                },
+            })
+        ], ComplexContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(ComplexContract);
+        expect(metadata?.schema.properties).toBeDefined();
+        expect(metadata?.schema.required).toEqual(['id']);
+    });
+    it('should handle tags', () => {
+        let TaggedContract = class TaggedContract {
+        };
+        TaggedContract = __decorate([
+            (0, contract_decorator_1.DataContract)({
+                name: 'tagged-contract',
+                version: '1.0.0',
+                owner: 'platform-team',
+                schema: { type: 'object', properties: {} },
+                tags: ['pii', 'critical', 'production'],
+            })
+        ], TaggedContract);
+        const metadata = (0, contract_decorator_1.getDataContractMetadata)(TaggedContract);
+        expect(metadata?.tags).toEqual(['pii', 'critical', 'production']);
+    });
+    describe('hasDataContractMetadata', () => {
+        it('should return true for decorated class', () => {
+            let DecoratedClass = class DecoratedClass {
+            };
+            DecoratedClass = __decorate([
+                (0, contract_decorator_1.DataContract)({
+                    name: 'test',
+                    version: '1.0.0',
+                    owner: 'team',
+                    schema: { type: 'object', properties: {} },
+                })
+            ], DecoratedClass);
+            expect((0, contract_decorator_1.hasDataContractMetadata)(DecoratedClass)).toBe(true);
+        });
+        it('should return false for non-decorated class', () => {
+            class NonDecoratedClass {
+            }
+            expect((0, contract_decorator_1.hasDataContractMetadata)(NonDecoratedClass)).toBe(false);
+        });
+    });
+});

package/dist/contracts/contract-registry.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Contract Registry - Manage data contracts and their versions
+ */
+import type { DataContract, ContractViolation, ContractDiff, ContractValidationResult } from './contract.types';
+export declare class ContractRegistry {
+    private contracts;
+    private violations;
+    /**
+     * Register a data contract
+     */
+    register(contract: DataContract): void;
+    /**
+     * Get a specific contract version
+     */
+    get(name: string, version?: string): DataContract | undefined;
+    /**
+     * List all versions of a contract
+     */
+    listVersions(name: string): string[];
+    /**
+     * List all contracts
+     */
+    listContracts(): Array<{
+        name: string;
+        versions: string[];
+        owner: string;
+    }>;
+    /**
+     * Deprecate a contract version
+     */
+    deprecate(name: string, version: string): void;
+    /**
+     * Compare two contract versions to detect breaking changes
+     */
+    diff(name: string, oldVersion: string, newVersion: string): ContractDiff;
+    /**
+     * Validate data against a contract
+     */
+    validate(name: string, data: unknown, version?: string): ContractValidationResult;
+    /**
+     * Record a contract violation
+     */
+    recordViolation(violation: ContractViolation): void;
+    /**
+     * Get violations for a contract
+     */
+    getViolations(name: string, version?: string): ContractViolation[];
+    /**
+     * Clear violations older than specified days
+     */
+    clearOldViolations(days: number): void;
+    private detectSchemaChanges;
+    private validateSchema;
+    private validateCompleteness;
+    private compareVersions;
+}
+//# sourceMappingURL=contract-registry.d.ts.map

package/dist/contracts/contract-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-registry.d.ts","sourceRoot":"","sources":["../../src/contracts/contract-registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EAEjB,YAAY,EACZ,wBAAwB,EACzB,MAAM,kBAAkB,CAAC;AAE1B,qBACa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAqD;IACtE,OAAO,CAAC,UAAU,CAA2B;IAE7C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAOtC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAa7D;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAMpC;;OAEG;IACH,aAAa,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAe3E;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAW9C;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY;IAqBxE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,wBAAwB;IAwCjF;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IASnD;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAMlE;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQtC,OAAO,CAAC,mBAAmB;IAmD3B,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,eAAe;CAYxB"}

package/dist/contracts/contract-registry.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Contract Registry - Manage data contracts and their versions
+ */
+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.ContractRegistry = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+let ContractRegistry = class ContractRegistry {
+    constructor() {
+        this.contracts = new Map();
+        this.violations = [];
+    }
+    /**
+     * Register a data contract
+     */
+    register(contract) {
+        const versions = this.contracts.get(contract.name) ?? new Map();
+        versions.set(contract.version, contract);
+        this.contracts.set(contract.name, versions);
+        core_2.default.debug(`Registered contract: ${contract.name}@${contract.version}`);
+    }
+    /**
+     * Get a specific contract version
+     */
+    get(name, version) {
+        const versions = this.contracts.get(name);
+        if (!versions)
+            return undefined;
+        if (version) {
+            return versions.get(version);
+        }
+        // Return latest version
+        const sorted = Array.from(versions.entries()).sort((a, b) => this.compareVersions(b[0], a[0]));
+        return sorted[0]?.[1];
+    }
+    /**
+     * List all versions of a contract
+     */
+    listVersions(name) {
+        const versions = this.contracts.get(name);
+        if (!versions)
+            return [];
+        return Array.from(versions.keys()).sort((a, b) => this.compareVersions(b, a));
+    }
+    /**
+     * List all contracts
+     */
+    listContracts() {
+        const result = [];
+        for (const [name, versions] of this.contracts) {
+            const latest = this.get(name);
+            result.push({
+                name,
+                versions: Array.from(versions.keys()),
+                owner: latest?.owner ?? 'unknown',
+            });
+        }
+        return result;
+    }
+    /**
+     * Deprecate a contract version
+     */
+    deprecate(name, version) {
+        const contract = this.get(name, version);
+        if (!contract) {
+            throw new Error(`Contract not found: ${name}@${version}`);
+        }
+        contract.status = 'deprecated';
+        contract.updatedAt = new Date();
+        core_2.default.debug(`Deprecated contract: ${name}@${version}`);
+    }
+    /**
+     * Compare two contract versions to detect breaking changes
+     */
+    diff(name, oldVersion, newVersion) {
+        const oldContract = this.get(name, oldVersion);
+        const newContract = this.get(name, newVersion);
+        if (!oldContract || !newContract) {
+            throw new Error(`Cannot compare: contract versions not found`);
+        }
+        const changes = this.detectSchemaChanges(oldContract.schema, newContract.schema);
+        const breakingChanges = changes.filter((c) => c.breaking);
+        return {
+            contractName: name,
+            oldVersion,
+            newVersion,
+            changes,
+            breakingChanges,
+            isBreaking: breakingChanges.length > 0,
+        };
+    }
+    /**
+     * Validate data against a contract
+     */
+    validate(name, data, version) {
+        const contract = this.get(name, version);
+        if (!contract) {
+            return {
+                valid: false,
+                violations: [
+                    {
+                        contractName: name,
+                        contractVersion: version ?? 'latest',
+                        violationType: 'schema',
+                        severity: 'error',
+                        message: `Contract not found: ${name}@${version ?? 'latest'}`,
+                        details: {},
+                        timestamp: new Date(),
+                    },
+                ],
+                warnings: [],
+            };
+        }
+        const violations = [];
+        const warnings = [];
+        // Schema validation
+        const schemaViolations = this.validateSchema(contract, data);
+        violations.push(...schemaViolations);
+        // SLA validation
+        if (contract.sla?.completeness) {
+            const completenessViolations = this.validateCompleteness(contract, data);
+            violations.push(...completenessViolations);
+        }
+        return {
+            valid: violations.length === 0,
+            violations,
+            warnings,
+        };
+    }
+    /**
+     * Record a contract violation
+     */
+    recordViolation(violation) {
+        this.violations.push(violation);
+        core_2.default.warn(`Contract violation: ${violation.contractName}@${violation.contractVersion}`, {
+            type: violation.violationType,
+            severity: violation.severity,
+            message: violation.message,
+        });
+    }
+    /**
+     * Get violations for a contract
+     */
+    getViolations(name, version) {
+        return this.violations.filter((v) => v.contractName === name && (!version || v.contractVersion === version));
+    }
+    /**
+     * Clear violations older than specified days
+     */
+    clearOldViolations(days) {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+        this.violations = this.violations.filter((v) => v.timestamp > cutoff);
+    }
+    // ─── Private Helpers ─────────────────────────────────────────────────────────
+    detectSchemaChanges(oldSchema, newSchema) {
+        const changes = [];
+        const allFields = new Set([...Object.keys(oldSchema), ...Object.keys(newSchema)]);
+        for (const field of allFields) {
+            const oldValue = oldSchema[field];
+            const newValue = newSchema[field];
+            if (oldValue === undefined && newValue !== undefined) {
+                // Field added
+                changes.push({
+                    field,
+                    changeType: 'added',
+                    newValue,
+                    breaking: false,
+                });
+            }
+            else if (oldValue !== undefined && newValue === undefined) {
+                // Field removed - BREAKING
+                changes.push({
+                    field,
+                    changeType: 'removed',
+                    oldValue,
+                    breaking: true,
+                });
+            }
+            else if (typeof oldValue !== typeof newValue) {
+                // Type changed - BREAKING
+                changes.push({
+                    field,
+                    changeType: 'type_changed',
+                    oldValue,
+                    newValue,
+                    breaking: true,
+                });
+            }
+            else if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+                // Field modified
+                changes.push({
+                    field,
+                    changeType: 'modified',
+                    oldValue,
+                    newValue,
+                    breaking: false,
+                });
+            }
+        }
+        return changes;
+    }
+    validateSchema(contract, data) {
+        const violations = [];
+        if (typeof data !== 'object' || data === null) {
+            violations.push({
+                contractName: contract.name,
+                contractVersion: contract.version,
+                violationType: 'schema',
+                severity: 'error',
+                message: 'Data must be an object',
+                details: { data },
+                timestamp: new Date(),
+            });
+            return violations;
+        }
+        const record = data;
+        // Check required fields from schema
+        for (const [field, fieldSchema] of Object.entries(contract.schema)) {
+            if (typeof fieldSchema === 'object' && fieldSchema !== null) {
+                const schema = fieldSchema;
+                if (schema.required === true && record[field] === undefined) {
+                    violations.push({
+                        contractName: contract.name,
+                        contractVersion: contract.version,
+                        violationType: 'schema',
+                        severity: 'error',
+                        message: `Required field missing: ${field}`,
+                        details: { field, schema },
+                        timestamp: new Date(),
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    validateCompleteness(contract, data) {
+        const violations = [];
+        const sla = contract.sla?.completeness;
+        if (!sla)
+            return violations;
+        const record = data;
+        const missingFields = sla.requiredFields.filter((f) => record[f] === undefined || record[f] === null);
+        if (missingFields.length > 0) {
+            const completeness = 1 - missingFields.length / sla.requiredFields.length;
+            if (completeness < sla.minCompleteness) {
+                violations.push({
+                    contractName: contract.name,
+                    contractVersion: contract.version,
+                    violationType: 'sla',
+                    severity: 'warning',
+                    message: `Completeness ${(completeness * 100).toFixed(1)}% below SLA ${(sla.minCompleteness * 100).toFixed(1)}%`,
+                    details: { missingFields, completeness, minCompleteness: sla.minCompleteness },
+                    timestamp: new Date(),
+                });
+            }
+        }
+        return violations;
+    }
+    compareVersions(a, b) {
+        const aParts = a.split('.').map(Number);
+        const bParts = b.split('.').map(Number);
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aPart = aParts[i] ?? 0;
+            const bPart = bParts[i] ?? 0;
+            if (aPart !== bPart)
+                return aPart - bPart;
+        }
+        return 0;
+    }
+};
+exports.ContractRegistry = ContractRegistry;
+exports.ContractRegistry = ContractRegistry = __decorate([
+    (0, core_1.Service)()
+], ContractRegistry);

package/dist/contracts/contract.decorator.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @DataContract decorator - Define a data contract for a pipeline or dataset
+ */
+import 'reflect-metadata';
+export declare const DATA_CONTRACT_METADATA_KEY: unique symbol;
+export interface DataContractOptions {
+    name: string;
+    version: string;
+    description?: string;
+    owner: string;
+    schema: Record<string, unknown>;
+    sla?: {
+        freshness?: {
+            maxDelayMinutes: number;
+            checkIntervalMinutes?: number;
+        };
+        completeness?: {
+            minCompleteness: number;
+            requiredFields: string[];
+        };
+        quality?: {
+            minQualityScore: number;
+            checks: string[];
+        };
+        availability?: {
+            minUptime: number;
+        };
+    };
+    consumers?: string[];
+    producers?: string[];
+    tags?: string[];
+}
+export interface DataContractMetadata extends DataContractOptions {
+    status: 'active' | 'deprecated' | 'breaking';
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Mark a pipeline or class as having a data contract.
+ * The contract defines the schema, SLA, and ownership of the data.
+ *
+ * @example
+ * ```typescript
+ * @DataContract({
+ *   name: 'user-events',
+ *   version: '1.0.0',
+ *   owner: 'analytics-team',
+ *   schema: {
+ *     userId: { type: 'string', required: true },
+ *     eventType: { type: 'string', required: true },
+ *     timestamp: { type: 'date', required: true },
+ *   },
+ *   sla: {
+ *     freshness: { maxDelayMinutes: 5 },
+ *     completeness: { minCompleteness: 0.95, requiredFields: ['userId', 'eventType'] }
+ *   },
+ *   consumers: ['recommendation-service', 'analytics-dashboard']
+ * })
+ * @Pipeline('user-events-pipeline')
+ * class UserEventsPipeline extends PipelineBase {
+ *   // ...
+ * }
+ * ```
+ */
+export declare function DataContract(options: DataContractOptions): <T extends {
+    new (...args: unknown[]): object;
+}>(target: T) => void;
+export declare function getDataContractMetadata(target: object): DataContractMetadata | undefined;
+export declare function hasDataContractMetadata(target: object): boolean;
+//# sourceMappingURL=contract.decorator.d.ts.map

package/dist/contracts/contract.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.decorator.d.ts","sourceRoot":"","sources":["../../src/contracts/contract.decorator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,0BAA0B,eAAyC,CAAC;AAEjF,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,GAAG,CAAC,EAAE;QACJ,SAAS,CAAC,EAAE;YACV,eAAe,EAAE,MAAM,CAAC;YACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;SAC/B,CAAC;QACF,YAAY,CAAC,EAAE;YACb,eAAe,EAAE,MAAM,CAAC;YACxB,cAAc,EAAE,MAAM,EAAE,CAAC;SAC1B,CAAC;QACF,OAAO,CAAC,EAAE;YACR,eAAe,EAAE,MAAM,CAAC;YACxB,MAAM,EAAE,MAAM,EAAE,CAAC;SAClB,CAAC;QACF,YAAY,CAAC,EAAE;YACb,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC;KACH,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D,MAAM,EAAE,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;IAC7C,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,IACtC,CAAC,SAAS;IAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAA;CAAE,EAAE,QAAQ,CAAC,KAAG,IAAI,CAUlF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAExF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE/D"}

package/dist/contracts/contract.decorator.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @DataContract decorator - Define a data contract for a pipeline or dataset
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_CONTRACT_METADATA_KEY = void 0;
+exports.DataContract = DataContract;
+exports.getDataContractMetadata = getDataContractMetadata;
+exports.hasDataContractMetadata = hasDataContractMetadata;
+require("reflect-metadata");
+exports.DATA_CONTRACT_METADATA_KEY = Symbol('hazel:data-contract:metadata');
+/**
+ * Mark a pipeline or class as having a data contract.
+ * The contract defines the schema, SLA, and ownership of the data.
+ *
+ * @example
+ * ```typescript
+ * @DataContract({
+ *   name: 'user-events',
+ *   version: '1.0.0',
+ *   owner: 'analytics-team',
+ *   schema: {
+ *     userId: { type: 'string', required: true },
+ *     eventType: { type: 'string', required: true },
+ *     timestamp: { type: 'date', required: true },
+ *   },
+ *   sla: {
+ *     freshness: { maxDelayMinutes: 5 },
+ *     completeness: { minCompleteness: 0.95, requiredFields: ['userId', 'eventType'] }
+ *   },
+ *   consumers: ['recommendation-service', 'analytics-dashboard']
+ * })
+ * @Pipeline('user-events-pipeline')
+ * class UserEventsPipeline extends PipelineBase {
+ *   // ...
+ * }
+ * ```
+ */
+function DataContract(options) {
+    return function (target) {
+        const metadata = {
+            ...options,
+            status: 'active',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        Reflect.defineMetadata(exports.DATA_CONTRACT_METADATA_KEY, metadata, target);
+    };
+}
+function getDataContractMetadata(target) {
+    return Reflect.getMetadata(exports.DATA_CONTRACT_METADATA_KEY, target);
+}
+function hasDataContractMetadata(target) {
+    return Reflect.hasMetadata(exports.DATA_CONTRACT_METADATA_KEY, target);
+}