@hazeljs/data 0.2.0-alpha.1

package/dist/connectors/csv.connector.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvSink = exports.CsvSource = void 0;
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+/**
+ * CSV file data source — reads records from a CSV file.
+ *
+ * @example
+ * const source = new CsvSource({ filePath: './data.csv', hasHeader: true });
+ * await source.open();
+ * const records = await source.readAll();
+ * await source.close();
+ */
+class CsvSource {
+    constructor(options) {
+        this.name = options.name ?? `csv:${options.filePath}`;
+        this.filePath = options.filePath;
+        this.delimiter = options.delimiter ?? ',';
+        this.hasHeader = options.hasHeader ?? true;
+        this.customHeaders = options.headers;
+    }
+    async open() {
+        if (!(0, fs_1.existsSync)(this.filePath)) {
+            throw new Error(`CSV file not found: ${this.filePath}`);
+        }
+    }
+    async close() {
+        // No-op for file reads
+    }
+    async readAll() {
+        const records = [];
+        for await (const record of this.read()) {
+            records.push(record);
+        }
+        return records;
+    }
+    async *read() {
+        const rl = (0, readline_1.createInterface)({
+            input: (0, fs_1.createReadStream)(this.filePath),
+            crlfDelay: Infinity,
+        });
+        let headers = this.customHeaders ?? null;
+        let isFirst = true;
+        for await (const line of rl) {
+            const cols = this.parseLine(line);
+            if (isFirst && this.hasHeader && !this.customHeaders) {
+                headers = cols;
+                isFirst = false;
+                continue;
+            }
+            isFirst = false;
+            if (!headers) {
+                headers = cols.map((_, i) => `col${i}`);
+            }
+            const record = {};
+            headers.forEach((h, i) => {
+                record[h] = cols[i] ?? '';
+            });
+            yield record;
+        }
+    }
+    parseLine(line) {
+        const result = [];
+        let current = '';
+        let inQuote = false;
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (ch === '"') {
+                if (inQuote && line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuote = !inQuote;
+                }
+            }
+            else if (ch === this.delimiter && !inQuote) {
+                result.push(current);
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+        result.push(current);
+        return result;
+    }
+}
+exports.CsvSource = CsvSource;
+/**
+ * CSV file data sink — writes records to a CSV file.
+ *
+ * @example
+ * const sink = new CsvSink({ filePath: './output.csv', writeHeader: true });
+ * await sink.open();
+ * await sink.writeBatch(records);
+ * await sink.close();
+ */
+class CsvSink {
+    constructor(options) {
+        this.headers = null;
+        this.stream = null;
+        this.headerWritten = false;
+        this.name = options.name ?? `csv:${options.filePath}`;
+        this.filePath = options.filePath;
+        this.delimiter = options.delimiter ?? ',';
+        this.writeHeader = options.writeHeader ?? true;
+    }
+    async open() {
+        this.stream = (0, fs_1.createWriteStream)(this.filePath, { encoding: 'utf8' });
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            if (!this.stream) {
+                resolve();
+                return;
+            }
+            this.stream.end((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async write(record) {
+        if (!this.stream)
+            throw new Error('CsvSink: call open() before write()');
+        if (!this.headers) {
+            this.headers = Object.keys(record);
+        }
+        if (this.writeHeader && !this.headerWritten) {
+            this.writeLine(this.headers);
+            this.headerWritten = true;
+        }
+        this.writeLine(this.headers.map((h) => String(record[h] ?? '')));
+    }
+    async writeBatch(records) {
+        for (const r of records)
+            await this.write(r);
+    }
+    writeLine(cols) {
+        const line = cols
+            .map((c) => c.includes(this.delimiter) || c.includes('"') || c.includes('\n')
+            ? `"${c.replace(/"/g, '""')}"`
+            : c)
+            .join(this.delimiter) + '\n';
+        this.stream.write(line);
+    }
+}
+exports.CsvSink = CsvSink;

package/dist/connectors/http.connector.d.ts

@@ -0,0 +1,68 @@
+import type { DataSource, DataSink } from './connector.interface';
+export interface HttpSourceOptions {
+    url: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: unknown;
+    /** JSON path to the array in the response (e.g. "data.items") */
+    dataPath?: string;
+    /** Pagination: next page URL extracted from response (e.g. "meta.next") */
+    nextPagePath?: string;
+    name?: string;
+    timeoutMs?: number;
+}
+export interface HttpSinkOptions {
+    url: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    /** Batch size — how many records to send per request (default: 1) */
+    batchSize?: number;
+    /** JSON field name to wrap records in (e.g. "records" → { records: [...] }) */
+    bodyKey?: string;
+    name?: string;
+    timeoutMs?: number;
+}
+/**
+ * HTTP API data source — reads records from a REST API.
+ * Supports pagination via `nextPagePath`.
+ *
+ * @example
+ * const source = new HttpSource({
+ *   url: 'https://api.example.com/users',
+ *   dataPath: 'data',
+ *   nextPagePath: 'meta.next',
+ * });
+ */
+export declare class HttpSource implements DataSource<unknown> {
+    readonly name: string;
+    private readonly options;
+    constructor(options: HttpSourceOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    readAll(): Promise<unknown[]>;
+    read(): AsyncGenerator<unknown>;
+    private fetchPage;
+}
+/**
+ * HTTP API data sink — writes records to a REST API endpoint.
+ *
+ * @example
+ * const sink = new HttpSink({
+ *   url: 'https://api.example.com/ingest',
+ *   method: 'POST',
+ *   batchSize: 100,
+ *   bodyKey: 'records',
+ * });
+ */
+export declare class HttpSink implements DataSink<unknown> {
+    readonly name: string;
+    private readonly options;
+    private buffer;
+    constructor(options: HttpSinkOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    write(record: unknown): Promise<void>;
+    writeBatch(records: unknown[]): Promise<void>;
+    private flush;
+}
+//# sourceMappingURL=http.connector.d.ts.map

package/dist/connectors/http.connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.connector.d.ts","sourceRoot":"","sources":["../../src/connectors/http.connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAElE,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AASD;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,YAAW,UAAU,CAAC,OAAO,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,EAAE,iBAAiB;IAKhC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAEtB,OAAO,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAM5B,IAAI,IAAI,cAAc,CAAC,OAAO,CAAC;IAwBtC,OAAO,CAAC,SAAS;CAYlB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,YAAW,QAAQ,CAAC,OAAO,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,MAAM,CAAiB;gBAEnB,OAAO,EAAE,eAAe;IAK9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAErB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAOrC,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YAKrC,KAAK;CA2BpB"}

package/dist/connectors/http.connector.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpSink = exports.HttpSource = void 0;
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((cur, key) => {
+        if (cur === null || cur === undefined || typeof cur !== 'object')
+            return undefined;
+        return cur[key];
+    }, obj);
+}
+/**
+ * HTTP API data source — reads records from a REST API.
+ * Supports pagination via `nextPagePath`.
+ *
+ * @example
+ * const source = new HttpSource({
+ *   url: 'https://api.example.com/users',
+ *   dataPath: 'data',
+ *   nextPagePath: 'meta.next',
+ * });
+ */
+class HttpSource {
+    constructor(options) {
+        this.name = options.name ?? `http:${options.url}`;
+        this.options = options;
+    }
+    async open() {
+        // Validate connectivity on open
+        const res = await this.fetchPage(this.options.url);
+        if (!res.ok)
+            throw new Error(`HttpSource: Cannot reach ${this.options.url} (${res.status})`);
+    }
+    async close() { }
+    async readAll() {
+        const all = [];
+        for await (const r of this.read())
+            all.push(r);
+        return all;
+    }
+    async *read() {
+        let url = this.options.url;
+        while (url) {
+            const res = await this.fetchPage(url);
+            if (!res.ok)
+                throw new Error(`HttpSource: ${res.status} ${await res.text()}`);
+            const body = await res.json();
+            const items = this.options.dataPath ? getNestedValue(body, this.options.dataPath) : body;
+            if (Array.isArray(items)) {
+                for (const item of items)
+                    yield item;
+            }
+            else {
+                yield body;
+                break;
+            }
+            url = this.options.nextPagePath
+                ? (getNestedValue(body, this.options.nextPagePath) ?? null)
+                : null;
+        }
+    }
+    fetchPage(url) {
+        const controller = new AbortController();
+        if (this.options.timeoutMs) {
+            setTimeout(() => controller.abort(), this.options.timeoutMs);
+        }
+        return fetch(url, {
+            method: this.options.method ?? 'GET',
+            headers: { 'Content-Type': 'application/json', ...this.options.headers },
+            body: this.options.body ? JSON.stringify(this.options.body) : undefined,
+            signal: controller.signal,
+        });
+    }
+}
+exports.HttpSource = HttpSource;
+/**
+ * HTTP API data sink — writes records to a REST API endpoint.
+ *
+ * @example
+ * const sink = new HttpSink({
+ *   url: 'https://api.example.com/ingest',
+ *   method: 'POST',
+ *   batchSize: 100,
+ *   bodyKey: 'records',
+ * });
+ */
+class HttpSink {
+    constructor(options) {
+        this.buffer = [];
+        this.name = options.name ?? `http:${options.url}`;
+        this.options = { batchSize: 1, ...options };
+    }
+    async open() { }
+    async close() {
+        if (this.buffer.length > 0)
+            await this.flush();
+    }
+    async write(record) {
+        this.buffer.push(record);
+        if (this.buffer.length >= (this.options.batchSize ?? 1)) {
+            await this.flush();
+        }
+    }
+    async writeBatch(records) {
+        this.buffer.push(...records);
+        await this.flush();
+    }
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        const payload = this.options.bodyKey
+            ? { [this.options.bodyKey]: this.buffer }
+            : this.buffer.length === 1
+                ? this.buffer[0]
+                : this.buffer;
+        const controller = new AbortController();
+        if (this.options.timeoutMs) {
+            setTimeout(() => controller.abort(), this.options.timeoutMs);
+        }
+        const res = await fetch(this.options.url, {
+            method: this.options.method ?? 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.options.headers },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`HttpSink: ${res.status} ${await res.text()}`);
+        }
+        this.buffer = [];
+    }
+}
+exports.HttpSink = HttpSink;

package/dist/connectors/index.d.ts

@@ -0,0 +1,7 @@
+export type { DataSource, DataSink, ConnectorOptions } from './connector.interface';
+export { CsvSource, CsvSink } from './csv.connector';
+export type { CsvSourceOptions, CsvSinkOptions } from './csv.connector';
+export { HttpSource, HttpSink } from './http.connector';
+export type { HttpSourceOptions, HttpSinkOptions } from './http.connector';
+export { MemorySource, MemorySink } from './memory.connector';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/connectors/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/connectors/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySink = exports.MemorySource = exports.HttpSink = exports.HttpSource = exports.CsvSink = exports.CsvSource = void 0;
+var csv_connector_1 = require("./csv.connector");
+Object.defineProperty(exports, "CsvSource", { enumerable: true, get: function () { return csv_connector_1.CsvSource; } });
+Object.defineProperty(exports, "CsvSink", { enumerable: true, get: function () { return csv_connector_1.CsvSink; } });
+var http_connector_1 = require("./http.connector");
+Object.defineProperty(exports, "HttpSource", { enumerable: true, get: function () { return http_connector_1.HttpSource; } });
+Object.defineProperty(exports, "HttpSink", { enumerable: true, get: function () { return http_connector_1.HttpSink; } });
+var memory_connector_1 = require("./memory.connector");
+Object.defineProperty(exports, "MemorySource", { enumerable: true, get: function () { return memory_connector_1.MemorySource; } });
+Object.defineProperty(exports, "MemorySink", { enumerable: true, get: function () { return memory_connector_1.MemorySink; } });

package/dist/connectors/memory.connector.d.ts

@@ -0,0 +1,38 @@
+import type { DataSource, DataSink } from './connector.interface';
+/**
+ * In-memory data source — wraps an array for use in pipelines and tests.
+ *
+ * @example
+ * const source = new MemorySource([{ id: 1 }, { id: 2 }]);
+ * const records = await source.readAll();
+ */
+export declare class MemorySource<T = unknown> implements DataSource<T> {
+    readonly name: string;
+    private readonly records;
+    constructor(records: T[], name?: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    readAll(): Promise<T[]>;
+    read(): AsyncGenerator<T>;
+}
+/**
+ * In-memory data sink — captures written records for inspection.
+ * Useful in tests and pipeline prototyping.
+ *
+ * @example
+ * const sink = new MemorySink<User>();
+ * await pipeline.run(source, sink);
+ * console.log(sink.records);
+ */
+export declare class MemorySink<T = unknown> implements DataSink<T> {
+    readonly name: string;
+    private _records;
+    constructor(name?: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    write(record: T): Promise<void>;
+    writeBatch(records: T[]): Promise<void>;
+    get records(): readonly T[];
+    clear(): void;
+}
+//# sourceMappingURL=memory.connector.d.ts.map

package/dist/connectors/memory.connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.connector.d.ts","sourceRoot":"","sources":["../../src/connectors/memory.connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAElE;;;;;;GAMG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,UAAU,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAM;gBAElB,OAAO,EAAE,CAAC,EAAE,EAAE,IAAI,SAAkB;IAK1C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IACrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAEtB,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAItB,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC;CAGjC;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAW;gBAEf,IAAI,SAAgB;IAI1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IACrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAEtB,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/B,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,IAAI,OAAO,IAAI,SAAS,CAAC,EAAE,CAE1B;IAED,KAAK,IAAI,IAAI;CAGd"}

package/dist/connectors/memory.connector.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySink = exports.MemorySource = void 0;
+/**
+ * In-memory data source — wraps an array for use in pipelines and tests.
+ *
+ * @example
+ * const source = new MemorySource([{ id: 1 }, { id: 2 }]);
+ * const records = await source.readAll();
+ */
+class MemorySource {
+    constructor(records, name = 'memory:source') {
+        this.name = name;
+        this.records = [...records];
+    }
+    async open() { }
+    async close() { }
+    async readAll() {
+        return [...this.records];
+    }
+    async *read() {
+        for (const r of this.records)
+            yield r;
+    }
+}
+exports.MemorySource = MemorySource;
+/**
+ * In-memory data sink — captures written records for inspection.
+ * Useful in tests and pipeline prototyping.
+ *
+ * @example
+ * const sink = new MemorySink<User>();
+ * await pipeline.run(source, sink);
+ * console.log(sink.records);
+ */
+class MemorySink {
+    constructor(name = 'memory:sink') {
+        this._records = [];
+        this.name = name;
+    }
+    async open() { }
+    async close() { }
+    async write(record) {
+        this._records.push(record);
+    }
+    async writeBatch(records) {
+        this._records.push(...records);
+    }
+    get records() {
+        return this._records;
+    }
+    clear() {
+        this._records = [];
+    }
+}
+exports.MemorySink = MemorySink;

package/dist/connectors/memory.connector.test.d.ts

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

package/dist/connectors/memory.connector.test.d.ts.map

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

package/dist/connectors/memory.connector.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_connector_1 = require("./memory.connector");
+describe('MemorySource', () => {
+    it('readAll returns all records', async () => {
+        const source = new memory_connector_1.MemorySource([{ id: 1 }, { id: 2 }]);
+        await source.open();
+        const records = await source.readAll();
+        expect(records).toHaveLength(2);
+        expect(records[0]).toEqual({ id: 1 });
+        await source.close();
+    });
+    it('read yields records', async () => {
+        const source = new memory_connector_1.MemorySource([1, 2, 3]);
+        const out = [];
+        for await (const r of source.read())
+            out.push(r);
+        expect(out).toEqual([1, 2, 3]);
+    });
+});
+describe('MemorySink', () => {
+    it('captures written records', async () => {
+        const sink = new memory_connector_1.MemorySink();
+        await sink.open();
+        await sink.write({ x: 1 });
+        await sink.write({ x: 2 });
+        await sink.close();
+        expect(sink.records).toHaveLength(2);
+        expect(sink.records[0]).toEqual({ x: 1 });
+    });
+    it('writeBatch captures batch', async () => {
+        const sink = new memory_connector_1.MemorySink();
+        await sink.open();
+        await sink.writeBatch([1, 2, 3]);
+        expect(sink.records).toEqual([1, 2, 3]);
+    });
+    it('clear resets records', async () => {
+        const sink = new memory_connector_1.MemorySink();
+        await sink.write(1);
+        sink.clear();
+        expect(sink.records).toHaveLength(0);
+    });
+});

package/dist/data.module.d.ts

@@ -0,0 +1,30 @@
+import type { FlinkClientConfig } from './streaming/flink/flink.client';
+export declare const DATA_FLINK_CONFIG: unique symbol;
+export interface DataModuleOptions {
+    flink?: FlinkClientConfig;
+}
+export declare class DataModule {
+    private static options;
+    /**
+     * Configure DataModule with optional Flink connection
+     *
+     * @example
+     * ```typescript
+     * imports: [
+     *   DataModule.forRoot({
+     *     flink: {
+     *       url: process.env.FLINK_REST_URL || 'http://localhost:8081',
+     *       timeout: 30000,
+     *     },
+     *   }),
+     * ]
+     * ```
+     */
+    static forRoot(options?: DataModuleOptions): {
+        module: typeof DataModule;
+        providers: unknown[];
+        exports: unknown[];
+    };
+    static getOptions(): DataModuleOptions;
+}
+//# sourceMappingURL=data.module.d.ts.map

package/dist/data.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.module.d.ts","sourceRoot":"","sources":["../src/data.module.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAExE,eAAO,MAAM,iBAAiB,eAAoC,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B;AAcD,qBAwBa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAyB;IAE/C;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,iBAAsB,GAAG;QAC/C,MAAM,EAAE,OAAO,UAAU,CAAC;QAC1B,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;IAkCD,MAAM,CAAC,UAAU,IAAI,iBAAiB;CAGvC"}

package/dist/data.module.js

@@ -0,0 +1,120 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var DataModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataModule = exports.DATA_FLINK_CONFIG = void 0;
+const core_1 = require("@hazeljs/core");
+const schema_validator_1 = require("./validators/schema.validator");
+const etl_service_1 = require("./pipelines/etl.service");
+const pipeline_builder_1 = require("./pipelines/pipeline.builder");
+const stream_service_1 = require("./pipelines/stream.service");
+const stream_builder_1 = require("./streaming/stream.builder");
+const stream_processor_1 = require("./streaming/stream.processor");
+const transformer_service_1 = require("./transformers/transformer.service");
+const quality_service_1 = require("./quality/quality.service");
+const flink_service_1 = require("./flink.service");
+exports.DATA_FLINK_CONFIG = Symbol('hazel:data:flink-config');
+let DataFlinkBootstrap = class DataFlinkBootstrap {
+    constructor(flinkService, config) {
+        this.flinkService = flinkService;
+        this.config = config;
+        if (this.config) {
+            this.flinkService.configure(this.config);
+        }
+    }
+};
+DataFlinkBootstrap = __decorate([
+    (0, core_1.Injectable)(),
+    __param(1, (0, core_1.Inject)(exports.DATA_FLINK_CONFIG)),
+    __metadata("design:paramtypes", [flink_service_1.FlinkService, Object])
+], DataFlinkBootstrap);
+let DataModule = DataModule_1 = class DataModule {
+    /**
+     * Configure DataModule with optional Flink connection
+     *
+     * @example
+     * ```typescript
+     * imports: [
+     *   DataModule.forRoot({
+     *     flink: {
+     *       url: process.env.FLINK_REST_URL || 'http://localhost:8081',
+     *       timeout: 30000,
+     *     },
+     *   }),
+     * ]
+     * ```
+     */
+    static forRoot(options = {}) {
+        DataModule_1.options = options;
+        const providers = [
+            schema_validator_1.SchemaValidator,
+            etl_service_1.ETLService,
+            pipeline_builder_1.PipelineBuilder,
+            stream_service_1.StreamService,
+            stream_builder_1.StreamBuilder,
+            stream_processor_1.StreamProcessor,
+            transformer_service_1.TransformerService,
+            quality_service_1.QualityService,
+            flink_service_1.FlinkService,
+            { provide: exports.DATA_FLINK_CONFIG, useValue: options.flink ?? null },
+            DataFlinkBootstrap,
+        ];
+        return {
+            module: DataModule_1,
+            providers,
+            exports: [
+                schema_validator_1.SchemaValidator,
+                etl_service_1.ETLService,
+                pipeline_builder_1.PipelineBuilder,
+                stream_service_1.StreamService,
+                stream_builder_1.StreamBuilder,
+                stream_processor_1.StreamProcessor,
+                transformer_service_1.TransformerService,
+                quality_service_1.QualityService,
+                flink_service_1.FlinkService,
+            ],
+        };
+    }
+    static getOptions() {
+        return DataModule_1.options;
+    }
+};
+exports.DataModule = DataModule;
+DataModule.options = {};
+exports.DataModule = DataModule = DataModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [
+            schema_validator_1.SchemaValidator,
+            etl_service_1.ETLService,
+            pipeline_builder_1.PipelineBuilder,
+            stream_service_1.StreamService,
+            stream_builder_1.StreamBuilder,
+            stream_processor_1.StreamProcessor,
+            transformer_service_1.TransformerService,
+            quality_service_1.QualityService,
+            flink_service_1.FlinkService,
+        ],
+        exports: [
+            schema_validator_1.SchemaValidator,
+            etl_service_1.ETLService,
+            pipeline_builder_1.PipelineBuilder,
+            stream_service_1.StreamService,
+            stream_builder_1.StreamBuilder,
+            stream_processor_1.StreamProcessor,
+            transformer_service_1.TransformerService,
+            quality_service_1.QualityService,
+            flink_service_1.FlinkService,
+        ],
+    })
+], DataModule);