@hazeljs/data 0.2.0-alpha.1

package/LICENSE

@@ -0,0 +1,192 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2024 HazelJS Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+   Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+   stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+   that You distribute, all copyright, patent, trademark, and
+   attribution notices from the Source form of the Work,
+   excluding those notices that do not pertain to any part of
+   the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+   distribution, then any Derivative Works that You distribute must
+   include a readable copy of the attribution notices contained
+   within such NOTICE file, excluding those notices that do not
+   pertain to any part of the Derivative Works, in at least one
+   of the following places: within a NOTICE text file distributed
+   as part of the Derivative Works; within the Source form or
+   documentation, if provided along with the Derivative Works; or,
+   within a display generated by the Derivative Works, if and
+   wherever such third-party notices normally appear. The contents
+   of the NOTICE file are for informational purposes only and
+   do not modify the License. You may add Your own attribution
+   notices within Derivative Works that You distribute, alongside
+   or as an addendum to the NOTICE text from the Work, provided
+   that such additional attribution notices cannot be construed
+   as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,308 @@
+# @hazeljs/data
+
+Data Processing & ETL for HazelJS - pipelines, schema validation, streaming, data quality, and more.
+
+[![npm version](https://img.shields.io/npm/v/@hazeljs/data.svg)](https://www.npmjs.com/package/@hazeljs/data)
+[![npm downloads](https://img.shields.io/npm/dm/@hazeljs/data)](https://www.npmjs.com/package/@hazeljs/data)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Features
+
+- **Pipelines** – Declarative ETL with `@Pipeline`, `@Transform`, `@Validate` decorators
+- **Schema validation** – Fluent Schema API (string, number, boolean, date, object, array, literal, union) with `.optional()`, `.nullable()`, `.default()`, `.transform()`, `.refine()`, `Infer<T>`, `.toJsonSchema()`
+- **Pipeline options** – Conditional steps (`when`), per-step retry, timeout, dead letter queue (DLQ)
+- **PipelineBuilder** – Programmatic pipelines with `.branch()`, `.parallel()`, `.catch()`, `.toSchema()`
+- **ETL service** – Execute multi-step pipelines with `executeBatch`, `onStepComplete`
+- **Stream processing** – StreamService, StreamProcessor with tumbling/sliding/session windows and stream join
+- **Built-in transformers** – trimString, toLowerCase, toUpperCase, parseJson, stringifyJson, pick, omit, renameKeys
+- **Data quality** – QualityService with completeness, notNull, uniqueness, range, pattern, referentialIntegrity, profile(), detectAnomalies()
+- **Connectors** – DataSource/DataSink (MemorySource, MemorySink, CsvSource, HttpSource)
+- **PII decorators** – @Mask, @Redact, @Encrypt, @Decrypt for sensitive data
+- **Test utilities** – SchemaFaker, PipelineTestHarness, MockSource, MockSink
+- **Flink integration** – Optional Apache Flink deployment for distributed stream processing
+
+## Installation
+
+```bash
+npm install @hazeljs/data @hazeljs/core
+```
+
+## Quick Start
+
+### 1. Import DataModule
+
+```typescript
+import { HazelApp } from '@hazeljs/core';
+import { DataModule } from '@hazeljs/data';
+
+const app = new HazelApp({
+  imports: [DataModule.forRoot()],
+});
+
+app.listen(3000);
+```
+
+### 2. Define a pipeline with decorators
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import {
+  Pipeline,
+  PipelineBase,
+  Transform,
+  Validate,
+  ETLService,
+  Schema,
+  Infer,
+} from '@hazeljs/data';
+
+const OrderSchema = Schema.object({
+  id: Schema.string().min(1),
+  customerId: Schema.string().min(1),
+  items: Schema.array(
+    Schema.object({
+      sku: Schema.string().min(1),
+      qty: Schema.number().min(1),
+      price: Schema.number().min(0),
+    })
+  ),
+  status: Schema.string().oneOf(['pending', 'paid', 'shipped', 'delivered', 'cancelled']),
+  createdAt: Schema.string().min(1),
+});
+
+type Order = Infer<typeof OrderSchema>;
+
+@Pipeline('order-processing')
+@Injectable()
+export class OrderProcessingPipeline extends PipelineBase {
+  constructor(etlService: ETLService) {
+    super(etlService);
+  }
+
+  @Transform({ step: 1, name: 'normalize' })
+  async normalize(data: unknown): Promise<Order> {
+    return { ...(data as Order), status: String((data as Order).status).toLowerCase() };
+  }
+
+  @Validate({ step: 2, name: 'validate', schema: OrderSchema })
+  async validate(data: Order): Promise<Order> {
+    return data;
+  }
+
+  @Transform({ step: 3, name: 'enrich' })
+  async enrich(data: Order): Promise<Order & { total: number; tax: number }> {
+    const items = data.items ?? [];
+    const subtotal = items.reduce((sum, i) => sum + i.qty * i.price, 0);
+    const tax = subtotal * 0.1;
+    return { ...data, subtotal, tax, total: subtotal + tax };
+  }
+}
+```
+
+### 3. Execute from a controller or service
+
+```typescript
+import { Controller, Post, Body, Inject } from '@hazeljs/core';
+import { OrderProcessingPipeline } from './pipelines/order-processing.pipeline';
+
+@Controller('data')
+export class DataController {
+  constructor(
+    @Inject(OrderProcessingPipeline) private pipeline: OrderProcessingPipeline
+  ) {}
+
+  @Post('pipeline/orders')
+  async processOrder(@Body() body: unknown) {
+    const result = await this.pipeline.execute(body);
+    return { ok: true, data: result };
+  }
+}
+```
+
+## Schema validation
+
+Build schemas with the fluent API. Full type inference via `Infer<T>`:
+
+```typescript
+import { Schema, Infer, SchemaValidator } from '@hazeljs/data';
+
+const UserSchema = Schema.object({
+  email: Schema.string().email(),
+  name: Schema.string().min(1).max(200),
+  age: Schema.number().min(0).max(150),
+  role: Schema.string().oneOf(['user', 'admin', 'moderator', 'guest']),
+  active: Schema.boolean().default(true),
+});
+
+type User = Infer<typeof UserSchema>;
+
+// Validate (throws on failure)
+const validator = new SchemaValidator();
+const user = validator.validate(UserSchema, rawData);
+
+// Safe validate (returns result)
+const result = validator.safeValidate(UserSchema, rawData);
+if (result.success) {
+  const user = result.data;
+} else {
+  console.error(result.errors);
+}
+```
+
+### Schema types and modifiers
+
+| Type | Example |
+|------|---------|
+| `Schema.string()` | `.email()`, `.url()`, `.min()`, `.max()`, `.uuid()`, `.oneOf()`, `.pattern()`, `.required()`, `.trim()` |
+| `Schema.number()` | `.min()`, `.max()`, `.integer()`, `.positive()`, `.negative()`, `.multipleOf()` |
+| `Schema.boolean()` | `.default()` |
+| `Schema.date()` | `.min()`, `.max()`, `.default()` |
+| `Schema.object({...})` | `.strict()`, `.pick()`, `.omit()`, `.extend()` |
+| `Schema.array(itemSchema)` | `.min()`, `.max()`, `.nonempty()` |
+| `Schema.literal(value)` | Literal values |
+| `Schema.union([a, b])` | Discriminated unions |
+| Modifiers | `.optional()`, `.nullable()`, `.default()`, `.transform()`, `.refine()`, `.refineAsync()` |
+
+## Pipeline options
+
+Steps support conditional execution, retry, timeout, and DLQ:
+
+```typescript
+@Transform({
+  step: 2,
+  name: 'enrich',
+  when: (data) => (data as { type: string }).type === 'order',
+  retry: { attempts: 3, delay: 500, backoff: 'exponential' },
+  timeoutMs: 5000,
+  dlq: { handler: (item, err, step) => logger.error('DLQ', { item, err, step }) },
+})
+async enrich(data: unknown) {
+  return { ...data, enriched: true };
+}
+```
+
+## PipelineBuilder (programmatic pipelines)
+
+Build pipelines in code without decorators:
+
+```typescript
+import { PipelineBuilder } from '@hazeljs/data';
+
+const pipeline = new PipelineBuilder('orders')
+  .addTransform('normalize', (d) => ({ ...d, email: (d as { email: string }).email?.toLowerCase() }))
+  .branch(
+    'classify',
+    (d) => (d as { type: string }).type === 'premium',
+    (b) => b.addTransform('enrichPremium', enrichPremium),
+    (b) => b.addTransform('enrichStandard', enrichStandard)
+  )
+  .parallel('enrich', [
+    (d) => ({ ...d, a: 1 }),
+    (d) => ({ ...d, b: 2 }),
+  ])
+  .catch((data, err) => ({ ...data, error: err.message }));
+
+const result = await pipeline.execute(rawData);
+```
+
+## Batch and stream processing
+
+```typescript
+import { StreamService, StreamProcessor } from '@hazeljs/data';
+
+// Batch
+const results = await streamService.processBatch(pipeline, items);
+
+// Streaming with windowing
+const processor = new StreamProcessor(etlService);
+for await (const batch of processor.tumblingWindow(source, 60_000)) {
+  console.log(batch.items, batch.windowStart, batch.windowEnd);
+}
+// Also: slidingWindow, sessionWindow, joinStreams
+```
+
+## Data quality
+
+```typescript
+import { QualityService } from '@hazeljs/data';
+
+const qualityService = new QualityService();
+
+qualityService.registerCheck('completeness', qualityService.completeness(['id', 'email']));
+qualityService.registerCheck('notNull', qualityService.notNull(['id']));
+qualityService.registerCheck('uniqueness', qualityService.uniqueness(['id']));
+qualityService.registerCheck('range', qualityService.range('age', { min: 0, max: 120 }));
+qualityService.registerCheck('pattern', qualityService.pattern('phone', /^\d{10}$/));
+qualityService.registerCheck('ref', qualityService.referentialIntegrity('status', ['active', 'inactive']));
+
+const report = await qualityService.runChecks('users', records);
+const profile = qualityService.profile('users', records);
+const anomalies = qualityService.detectAnomalies(records, ['value'], 2);
+```
+
+## PII decorators
+
+```typescript
+import { Transform, Mask, Redact } from '@hazeljs/data';
+
+@Transform({ step: 1, name: 'sanitize' })
+@Mask({ fields: ['email', 'ssn'], showLast: 4 })
+sanitize(data: User) {
+  return data; // email/ssn already masked
+}
+
+@Transform({ step: 2, name: 'redact' })
+@Redact({ fields: ['internalId'] })
+redact(data: Record<string, unknown>) {
+  return data; // internalId removed
+}
+```
+
+## Test utilities
+
+```typescript
+import { SchemaFaker, PipelineTestHarness, MockSource, MockSink } from '@hazeljs/data';
+
+const fake = SchemaFaker.generate(UserSchema);
+const many = SchemaFaker.generateMany(UserSchema, 10);
+
+const harness = PipelineTestHarness.create(etlService, pipeline);
+const { result, events } = await harness.run(input);
+await harness.runAndAssertSuccess(input);
+
+const source = new MockSource([{ x: 1 }]);
+const sink = new MockSink();
+```
+
+## Built-in transformers
+
+| Transformer | Description |
+|-------------|-------------|
+| `trimString` | Trim whitespace from strings |
+| `toLowerCase` / `toUpperCase` | Case conversion |
+| `parseJson` / `stringifyJson` | JSON parsing and serialization |
+| `pick` | Select specific keys from objects |
+| `omit` | Remove specific keys from objects |
+| `renameKeys` | Rename object keys |
+
+## Flink configuration (optional)
+
+```typescript
+DataModule.forRoot({
+  flink: {
+    url: process.env.FLINK_REST_URL ?? 'http://localhost:8081',
+    timeout: 30000,
+  },
+});
+```
+
+## Example
+
+See [hazeljs-data-starter](../../../hazeljs-data-starter) for a full example with order and user pipelines, PipelineBuilder, PII decorators, quality profiling, anomaly detection, and REST API.
+
+## Links
+
+- [Documentation](https://hazeljs.com/docs/packages/data)
+- [GitHub](https://github.com/hazel-js/hazeljs)
+- [Issues](https://github.com/hazel-js/hazeljs/issues)
+- [Homepage](https://hazeljs.com)

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

@@ -0,0 +1,29 @@
+/**
+ * Connector interfaces for data sources and sinks.
+ * All connectors implement DataSource<T> or DataSink<T>.
+ */
+export interface DataSource<T = unknown> {
+    readonly name: string;
+    /** Open/initialize the connection */
+    open(): Promise<void>;
+    /** Close/release the connection */
+    close(): Promise<void>;
+    /** Read all records as an array */
+    readAll(): Promise<T[]>;
+    /** Read records as an async generator (streaming) */
+    read(): AsyncGenerator<T>;
+}
+export interface DataSink<T = unknown> {
+    readonly name: string;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    /** Write a single record */
+    write(record: T): Promise<void>;
+    /** Write a batch of records (more efficient when supported) */
+    writeBatch(records: T[]): Promise<void>;
+}
+export interface ConnectorOptions {
+    /** Connector display name */
+    name?: string;
+}
+//# sourceMappingURL=connector.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connector.interface.d.ts","sourceRoot":"","sources":["../../src/connectors/connector.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,mCAAmC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,mCAAmC;IACnC,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACxB,qDAAqD;IACrD,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,4BAA4B;IAC5B,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,+DAA+D;IAC/D,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/connectors/connector.interface.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Connector interfaces for data sources and sinks.
+ * All connectors implement DataSource<T> or DataSink<T>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,63 @@
+import type { DataSource, DataSink } from './connector.interface';
+export interface CsvSourceOptions {
+    filePath: string;
+    delimiter?: string;
+    hasHeader?: boolean;
+    /** Custom header names (used when hasHeader is false) */
+    headers?: string[];
+    name?: string;
+}
+export interface CsvSinkOptions {
+    filePath: string;
+    delimiter?: string;
+    /** Write header row on open */
+    writeHeader?: boolean;
+    name?: string;
+}
+/**
+ * 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();
+ */
+export declare class CsvSource implements DataSource<Record<string, string>> {
+    readonly name: string;
+    private readonly filePath;
+    private readonly delimiter;
+    private readonly hasHeader;
+    private readonly customHeaders?;
+    constructor(options: CsvSourceOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    readAll(): Promise<Record<string, string>[]>;
+    read(): AsyncGenerator<Record<string, string>>;
+    private parseLine;
+}
+/**
+ * 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();
+ */
+export declare class CsvSink implements DataSink<Record<string, unknown>> {
+    readonly name: string;
+    private readonly filePath;
+    private readonly delimiter;
+    private readonly writeHeader;
+    private headers;
+    private stream;
+    private headerWritten;
+    constructor(options: CsvSinkOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    write(record: Record<string, unknown>): Promise<void>;
+    writeBatch(records: Record<string, unknown>[]): Promise<void>;
+    private writeLine;
+}
+//# sourceMappingURL=csv.connector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csv.connector.d.ts","sourceRoot":"","sources":["../../src/connectors/csv.connector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAElE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,qBAAa,SAAU,YAAW,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAW;gBAE9B,OAAO,EAAE,gBAAgB;IAQ/B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAQ3C,IAAI,IAAI,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IA4BrD,OAAO,CAAC,SAAS;CAwBlB;AAED;;;;;;;;GAQG;AACH,qBAAa,OAAQ,YAAW,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,MAAM,CAAqD;IACnE,OAAO,CAAC,aAAa,CAAS;gBAElB,OAAO,EAAE,cAAc;IAO7B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAerD,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE,OAAO,CAAC,SAAS;CAWlB"}