@reventlessdev/rescript-fast-csv 1.2.0-alpha.11

package/CHANGELOG.md

@@ -0,0 +1,124 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# 1.2.0-alpha.11 (2026-06-23)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.10 (2026-06-10)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.9 (2026-06-06)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.8 (2026-06-04)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.7 (2026-05-25)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.6 (2026-05-25)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.5 (2026-04-22)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# 1.2.0-alpha.4 (2026-04-06)
+
+### Bug Fixes
+
+* add package-specs to all rescript.json to prevent CJS .js output ([780f1e0](https://github.com/ReventlessDev/reventless-core/commit/780f1e035173b73b17b78466ad01fb69c7cca350))
+
+
+# [1.2.0-alpha.3](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.2.0-alpha.0...@reventlessdev/rescript-fast-csv@1.2.0-alpha.3) (2026-03-27)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# [1.2.0-alpha.2](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.2.0-alpha.0...@reventlessdev/rescript-fast-csv@1.2.0-alpha.2) (2026-03-26)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# [1.2.0-alpha.1](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.2.0-alpha.0...@reventlessdev/rescript-fast-csv@1.2.0-alpha.1) (2026-03-26)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+
+
+
+
+# [1.2.0-alpha.0](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.5...@reventlessdev/rescript-fast-csv@1.2.0-alpha.0) (2026-03-12)
+
+### Features
+
+* **deps:** upgrade rescript to 12.2 and migrate Belt usages to stdlib ([eaa96ea](https://github.com/ReventlessDev/reventless-core/commit/eaa96ea61ca40d61573fb5fe2002a1f73d43ce3e))
+## [1.1.3-alpha.5](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.4...@reventlessdev/rescript-fast-csv@1.1.3-alpha.5) (2026-03-02)
+
+### Bug Fixes
+
+* **rescript:** stable .res.mjs output for all rescript binding packages ([6d8f8cb](https://github.com/ReventlessDev/reventless-core/commit/6d8f8cbd6ca5152a29bfe1a598a193e4c92549b1))
+## [1.1.3-alpha.4](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.3...@reventlessdev/rescript-fast-csv@1.1.3-alpha.4) (2026-03-01)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+## [1.1.3-alpha.3](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.2...@reventlessdev/rescript-fast-csv@1.1.3-alpha.3) (2026-02-14)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+## [1.1.3-alpha.2](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.1...@reventlessdev/rescript-fast-csv@1.1.3-alpha.2) (2026-02-12)
+
+**Note:** Version bump only for package @reventlessdev/rescript-fast-csv
+
+## [1.1.3-alpha.1](https://github.com/ReventlessDev/reventless-core/compare/@reventlessdev/rescript-fast-csv@1.1.3-alpha.0...@reventlessdev/rescript-fast-csv@1.1.3-alpha.1) (2026-02-12)
+### Bug Fixes
+
+* exclude private packages from versioning and automate doc CHANGELOG updates ([7581d78](https://github.com/ReventlessDev/reventless-core/commit/7581d78e9825fa6d837da8a136b361dee821660f))
+
+## 1.1.3-alpha.0 (2026-02-12)
+### Bug Fixes
+
+* **publish:** add publishConfig to packages for GitHub Package Registry ([987a00a](https://github.com/ReventlessDev/reventless-core/commit/987a00af049fed112aa91fd53d8fad719cd80c94))
+* remove outdated bsconfig.json references, fix hash-obj title (qa-requested) ([4e5edd3](https://github.com/ReventlessDev/reventless-core/commit/4e5edd313c2cf7dbda4ad3ee6ac74c562739bbd3))

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019-2026 Martin Lorenz
+
+   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.

package/README.md

@@ -0,0 +1,294 @@
+[![npm version](https://img.shields.io/npm/v/@reventlessdev/rescript-fast-csv.svg?label=version)](https://www.npmjs.com/package/@reventlessdev/rescript-fast-csv)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Changelog](https://img.shields.io/badge/📋-Changelog-blue)](./CHANGELOG.md)
+
+# `rescript-fast-csv`
+
+ReScript bindings for [fast-csv](https://github.com/C2FO/fast-csv), a fast and flexible CSV parsing library for Node.js.
+
+## Installation
+- Add `rescript-fast-csv` to your dependencies in `package.json`.
+- Add `rescript-fast-csv` to your dependencies in `rescript.json`.
+- For general information see this monorepo's [readme](../../README.md)
+
+## Core API
+
+### Parsing Functions
+
+#### `parseFile`
+Parse a CSV file from the filesystem.
+
+```rescript
+parseFile(~path: string, ~options: Options.t=?) => csvParserStream
+```
+
+**Example:**
+```rescript
+FastCSV.parseFile(
+  ~path="data.csv",
+  ~options={
+    headers: Bool(true),
+    delimiter: ","
+  }
+)
+```
+
+#### `parseStream`
+Parse a CSV from a Node.js readable stream.
+
+```rescript
+parseStream(~stream: NodeStreams.Readable.t, ~options: Options.t=?) => csvParserStream
+```
+
+### Parser Options
+
+Configure the CSV parser behavior using the `Options.t` type:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `objectMode` | `bool` | `true` | Parse rows as objects with named fields |
+| `delimiter` | `string` | `","` | Character used to separate columns |
+| `quote` | `Js.Nullable.t<string>` | `'"'` | Character used to quote fields |
+| `escape` | `string` | `'"'` | Character used to escape quotes |
+| `headers` | `Bool(bool)` \| `String(array<string>)` | `false` | Use first row as headers or provide custom headers |
+| `renameHeaders` | `bool` | `false` | Allow headers to be renamed |
+| `ignoreEmpty` | `bool` | `false` | Skip empty rows |
+| `comment` | `string` | `null` | Character that starts comment lines (skipped) |
+| `discardUnmappedColumns` | `bool` | `false` | Discard columns not in headers |
+| `strictColumnHandling` | `bool` | `false` | Throw error if row column count differs from headers |
+| `trim` | `bool` | `false` | Trim whitespace from both ends of fields |
+| `rtrim` | `bool` | `false` | Trim whitespace from right end of fields |
+| `ltrim` | `bool` | `false` | Trim whitespace from left end of fields |
+
+**Example:**
+```rescript
+{
+  Options.headers: Bool(true),
+  delimiter: ";",
+  trim: true,
+  ignoreEmpty: true,
+  comment: "#"
+}
+```
+
+### Event Handling Pattern
+
+The parser uses a chainable event handler pattern. Register handlers to process rows, handle errors, and track completion:
+
+#### `onData`
+Called for each valid row parsed from the CSV.
+
+```rescript
+onData(csvParserStream, row => unit) => csvParserStream
+```
+
+**Example:**
+```rescript
+parseFile(~path="users.csv")
+->onData(row => {
+  Js.log2("Parsed row:", row)
+})
+```
+
+#### `onError`
+Called when the parser encounters an error.
+
+```rescript
+onError(csvParserStream, Js.Exn.t => unit) => csvParserStream
+```
+
+**Example:**
+```rescript
+parseFile(~path="data.csv")
+->onError(err => {
+  switch Js.Exn.message(err) {
+  | Some(msg) => Js.log2("Parse error:", msg)
+  | None => Js.log("Unknown parse error")
+  }
+})
+```
+
+#### `onEnd`
+Called when parsing completes. Receives the total row count.
+
+```rescript
+onEnd(csvParserStream, rowCount => unit) => csvParserStream
+```
+
+**Example:**
+```rescript
+parseFile(~path="data.csv")
+->onEnd(count => {
+  Js.log(`Finished parsing ${count->Int.toString} rows`)
+})
+```
+
+#### `onInvalid`
+Called when a row fails validation. Only triggered if validation is registered.
+
+```rescript
+onInvalid(csvParserStream, (row, rowNumber, option<reason>) => unit) => csvParserStream
+```
+
+**Example:**
+```rescript
+parseFile(~path="data.csv")
+->validate((row, callback) => {
+  // Validation logic
+  callback->toInvalid("Missing required field")
+})
+->onInvalid((row, rowNum, reason) => {
+  switch reason {
+  | Some(msg) => Js.log2(`Row ${rowNum->Int.toString} invalid:`, msg)
+  | None => Js.log2(`Row ${rowNum->Int.toString} has structural errors`, row)
+  }
+})
+```
+
+## Complete Example: Processing User Data
+
+```rescript
+// Parse a CSV file with user data, validate entries, transform them,
+// and handle errors gracefully
+
+type user = {
+  name: string,
+  email: string,
+  age: int,
+}
+
+let users = ref([])
+
+FastCSV.parseFile(
+  ~path="users.csv",
+  ~options={
+    headers: Bool(true),
+    delimiter: ",",
+    trim: true,
+    ignoreEmpty: true,
+  }
+)
+->FastCSV.validate((row, callback) => {
+  // Check if required fields exist
+  switch (Dict.get(row, "name"), Dict.get(row, "email"), Dict.get(row, "age")) {
+  | (Some(_), Some(_), Some(_)) => callback->FastCSV.toValid
+  | _ => callback->FastCSV.toInvalid("Missing required fields (name, email, age)")
+  }
+})
+->FastCSV.transform((row, callback) => {
+  // Transform row data
+  let name = Dict.get(row, "name")->Option.getOr("")
+  let email = Dict.get(row, "email")->Option.getOr("")
+  let ageStr = Dict.get(row, "age")->Option.getOr("0")
+
+  // Add transformed fields back to row
+  Dict.set(row, "email", String.toLowerCase(email))
+  Dict.set(row, "name", String.trim(name))
+
+  callback->FastCSV.toValidTransformation(row)
+})
+->FastCSV.onData(row => {
+  // Process each valid row
+  switch (
+    Dict.get(row, "name"),
+    Dict.get(row, "email"),
+    Dict.get(row, "age")->Option.flatMap(Int.fromString)
+  ) {
+  | (Some(name), Some(email), Some(age)) => {
+      let user = {name, email, age}
+      users := Array.concat(users.contents, [user])
+    }
+  | _ => Js.log2("Skipping invalid row:", row)
+  }
+})
+->FastCSV.onInvalid((row, rowNumber, reason) => {
+  let msg = reason->Option.getOr("Structural error")
+  Js.log(`Row ${rowNumber->Int.toString}: ${msg}`)
+})
+->FastCSV.onError(err => {
+  switch Js.Exn.message(err) {
+  | Some(msg) => Js.log2("Parse error:", msg)
+  | None => Js.log("Unknown parsing error occurred")
+  }
+})
+->FastCSV.onEnd(rowCount => {
+  Js.log(`Successfully parsed ${rowCount->Int.toString} rows`)
+  Js.log2("Total valid users:", Array.length(users.contents))
+})
+```
+
+## Validation
+
+### Simple Validation
+Use `validate` to register a validation function:
+
+```rescript
+parseFile(~path="data.csv")
+->validate((row, callback) => {
+  let hasRequiredField = Dict.get(row, "id")->Option.isSome
+  if hasRequiredField {
+    callback->toValid
+  } else {
+    callback->toInvalid("Missing id field")
+  }
+})
+```
+
+### Result-Based Validation
+Use `validateResult` for cleaner validation with Result types:
+
+```rescript
+parseFile(~path="data.csv")
+->validateResult(row => {
+  switch Dict.get(row, "email") {
+  | Some(email) if String.includes(email, "@") => Ok()
+  | Some(_) => Error("Invalid email format")
+  | None => Error("Email field is missing")
+  }
+})
+```
+
+### Multiple Validations
+Use `validateMultiple` or `validateMultipleResults` to chain validations:
+
+```rescript
+let validations = [
+  row => Dict.get(row, "name")->Option.isSome ? Ok() : Error("Missing name"),
+  row => Dict.get(row, "age")->Option.isSome ? Ok() : Error("Missing age"),
+]
+
+parseFile(~path="data.csv")
+->validateMultipleResults(validations)
+```
+
+## Transformation
+
+Transform row data during parsing:
+
+```rescript
+parseFile(~path="data.csv")
+->transform((row, callback) => {
+  // Normalize field names by removing empty keys
+  Dict.forEach(row, (value, key) => {
+    if String.length(key) == 0 {
+      Dict.delete(row, key)
+    }
+  })
+
+  // Convert certain fields to uppercase
+  switch Dict.get(row, "code") {
+  | Some(code) => Dict.set(row, "code", String.toUpperCase(code))
+  | None => ()
+  }
+
+  callback->toValidTransformation(row)
+})
+```
+
+## Helper Functions
+
+- `toValid(callback)` - Mark validation as successful
+- `toInvalid(callback, reason)` - Mark validation as failed with reason
+- `toError(callback, reason)` - Mark validation as error
+- `toValidTransformation(callback, row)` - Complete transformation successfully
+- `toErrorTransformation(callback, reason)` - Mark transformation as failed

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@reventlessdev/rescript-fast-csv",
+  "version": "1.2.0-alpha.11",
+  "description": "ReScript bindings for fast-csv",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "test": "echo \"There are no tests for rescript-fast-csv.\"",
+    "postpublish": "git checkout package.json & echo 'Please ensure the CHANGELOG is up to date!'"
+  },
+  "dependencies": {
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
+    "fast-csv": "^5.0.5"
+  },
+  "devDependencies": {
+    "rescript": "^12.3.0"
+  },
+  "peerDependencies": {
+    "rescript": "^12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReventlessDev/reventless-core.git",
+    "directory": "rescript/rescript-fast-csv"
+  },
+  "gitHead": "c85024f7b9724d4215d34ecc712a14b43eac289d"
+}

package/rescript.json

@@ -0,0 +1,23 @@
+{
+  "name": "@reventlessdev/rescript-fast-csv",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": false,
+  "suffix": ".res.mjs",
+  "ppx-flags": [],
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "dependencies": [
+    "@reventlessdev/rescript-node-streams"
+  ],
+  "compiler-flags": []
+}

package/src/FastCSV.res

@@ -0,0 +1,162 @@
+/*** Bindings for FastCSV library
+    https://github.com/C2FO/fast-csv/blob/HEAD/docs/parsing.md
+*/
+
+module Options = {
+  @unboxed
+  type headers = Bool(bool) | String(array<string>)
+  type t = {
+    /** default: true */
+    objectMode?: bool,
+    /** default: "," */
+    delimiter?: string,
+    /** default: '"' */
+    quote?: Nullable.t<string>,
+    /** default: '"' */
+    escape?: string,
+    /** default: false  | this could also be array(string), see setHeaders(t, array(string) */
+    headers?: headers,
+    /** default: false */
+    renameHeaders?: bool,
+    /** default: false */
+    ignoreEmpty?: bool,
+    /** default: null */
+    comment?: string,
+    /** default: false */
+    discardUnmappedfolumns?: bool,
+    /** default: false */
+    strictColumnHandling?: bool,
+    /** default: false */
+    trim?: bool,
+    /** default: false */
+    rtrim?: bool,
+    /** default: false */
+    ltrim?: bool,
+  }
+}
+
+/** Parser object */
+type csvParserStream
+type rowCount = int
+type row = dict<string>
+type rowNumber = int
+type reason = string
+
+type calledBack
+
+/** Callback to be used for potentially async validation
+ *  params:
+ *    - a js Error object or null if there was no error
+ *    - bool if given record is valid
+ *    - reason, why the given record was invalid
+ */
+type callback = (Nullable.t<JsExn.t>, bool, option<reason>) => calledBack
+type validation = (row, callback) => calledBack
+
+type transformCalledBack
+type transformCallback = (Nullable.t<JsExn.t>, option<row>) => transformCalledBack
+type transformation = (row, transformCallback) => transformCalledBack
+
+type importerValidation = row => result<unit, string>
+
+/** Create a parser for a given filename and options
+  example:
+  ```rescript
+    parseFile(
+      ~path=\"x\",
+      ~options=
+        {
+          Options.headers: Bool(true),
+          delimiter: ";"
+        }
+    )
+  ```
+*/
+@module("fast-csv")
+external parseFile: (~path: string, ~options: Options.t=?) => csvParserStream = "parseFile"
+
+/** Create a parser for a given node stream (readable) */
+@module("fast-csv")
+external parseStream: (~stream: NodeStreams.Readable.t, ~options: Options.t=?) => csvParserStream =
+  "parseStream"
+
+/** Register a validation function
+  the first row validating to false, will be passed to the onInvalid handler
+  example:
+  ```rescript
+    parseFile(~path="x")
+    -> validate((_row, callback) =>
+        callback -> toInvalid(\"reason for being invalid\")
+       )
+  ```
+*/
+@send
+external validate: (csvParserStream, validation) => csvParserStream = "validate"
+
+/** Transform a row
+  example:
+  ```rescript
+    parseFile(~path="x")
+    -> transform((row, cb) => {
+          Dict.delete(row, \"\"); /* remove property with empty name from row */
+          cb |> toValidTransformation(row); /* state a successfull transformation */
+        })
+  ```
+*/
+@send
+external transform: (csvParserStream, transformation) => csvParserStream = "transform"
+
+/** Register a handler to be called if the parser encounters an error
+  example:
+  ```rescript
+    parseFile(~path="x")
+    -> onError(err => err -> Js.Exn.message -> Console.log2("error during parsing:"))
+  ```
+*/
+@send
+external onError: (csvParserStream, @as("error") _, JsExn.t => unit) => csvParserStream = "on"
+
+/** Register a handler to be called if a data-set were parsed and evaluated as valid
+  example:
+  ```rescript
+    parseFile(~path="x"))
+    -> onData(row => row -> Console.log2("parsed line:"))
+  ```
+*/
+@send
+external onData: (csvParserStream, @as("data") _, row => unit) => csvParserStream = "on"
+
+/** Register a handler to be called if the parsing has been completed
+  example:
+  ```rescript
+    parseFile(~path="x"))
+    -> onEnd(rowCount => Console.log(`${rowCount->RescriptCore.Int.toString} rows parsed`))
+  ```
+*/
+@send
+external onEnd: (csvParserStream, @as("end") _, rowCount => unit) => csvParserStream = "on"
+
+/** Register handler to be called if a data-set is invalid
+  example:
+  ```rescript
+    parseFile(~path="x")
+    -> validate((_row, callback) =>
+        callback -> toInvalid("reason for being invalid")
+       )
+    -> onInvalid((row, rowNumber, reason) =>
+        switch (reason) {
+          | None => Console.log2(`line (${rowNumber->RescriptCore.Int.toString}) has too many/view records:`, row)
+          | Some(reason) => Console.log2(`line (${rowNumber->RescriptCore.Int.toString}) is invalid: ${reason}`, row)
+        }
+       )
+  ```
+*/
+@send
+external onInvalid: (
+  csvParserStream,
+  @as("data-invalid") _,
+  (row, rowNumber, option<reason>) => unit,
+) => csvParserStream = "on"
+
+@new
+external makeError: string => JsExn.t = "Error"

package/src/FastCSV.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Options = {};
+
+export {
+  Options,
+}
+/* No side effect */

package/src/FastCSV_Helpers.res

@@ -0,0 +1,47 @@
+/** Call the validation-callback function for an invalid data-set */
+let toInvalid: (FastCSV.callback, FastCSV.reason) => FastCSV.calledBack = (cb, reason) =>
+  cb(Nullable.null, false, Some(reason))
+
+/** Call the validation-callback function for a valid data-set */
+let toValid: FastCSV.callback => FastCSV.calledBack = cb => cb(Nullable.null, true, None)
+
+/** Call the validation-callback function for an error in the data-set */
+let toError: (FastCSV.callback, FastCSV.reason) => FastCSV.calledBack = (cb, reason) =>
+  cb(Nullable.make(FastCSV.makeError(reason)), false, Some(reason))
+
+/** Call the transformation-callback function for a valid transformation */
+let toValidTransformation: (FastCSV.transformCallback, FastCSV.row) => FastCSV.transformCalledBack = (cb, row) =>
+  cb(Nullable.null, Some(row))
+
+/** Call the transformation-callback function for an error in the transformation */
+let toErrorTransformation: (FastCSV.transformCallback, FastCSV.reason) => FastCSV.transformCalledBack = (cb, reason) =>
+  cb(Nullable.make(FastCSV.makeError(reason)), None)
+
+/** Add callback for validation to Result - to be used in validation function */
+let fromImporterValidation: FastCSV.importerValidation => FastCSV.validation = validation =>
+  (row, cb) =>
+    switch row->validation {
+    | Ok(_) => cb->toValid
+    | Error(msg) => cb->toInvalid(msg)
+    }
+
+/** Register multiple validation-functions, which will be called separately */
+let validateMultiple: (array<FastCSV.validation>, FastCSV.csvParserStream) => FastCSV.csvParserStream = (
+  validations,
+  parser,
+) => validations->Array.reduce(parser, (parser', validation) => parser'->FastCSV.validate(validation))
+
+/** Register a single validation function based on result */
+let validateResult: (FastCSV.csvParserStream, FastCSV.importerValidation) => FastCSV.csvParserStream = (
+  parser,
+  validation,
+) => parser->FastCSV.validate(validation->fromImporterValidation)
+
+/** Register multiple result based validation functions, which will be called separately */
+let validateMultipleResults: (FastCSV.csvParserStream, array<FastCSV.importerValidation>) => FastCSV.csvParserStream = (
+  parser,
+  validations,
+) =>
+  validations
+  ->Array.map(validation => validation->fromImporterValidation)
+  ->validateMultiple(parser)

package/src/FastCSV_Helpers.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+function toInvalid(cb, reason) {
+  return cb(null, false, reason);
+}
+
+function toValid(cb) {
+  return cb(null, true, undefined);
+}
+
+function toError(cb, reason) {
+  return cb(new Error(reason), false, reason);
+}
+
+function toValidTransformation(cb, row) {
+  return cb(null, row);
+}
+
+function toErrorTransformation(cb, reason) {
+  return cb(new Error(reason), undefined);
+}
+
+function fromImporterValidation(validation) {
+  return (row, cb) => {
+    let msg = validation(row);
+    if (msg.TAG === "Ok") {
+      return cb(null, true, undefined);
+    } else {
+      return toInvalid(cb, msg._0);
+    }
+  };
+}
+
+function validateMultiple(validations, parser) {
+  return Stdlib_Array.reduce(validations, parser, (parser$p, validation) => parser$p.validate(validation));
+}
+
+function validateResult(parser, validation) {
+  return parser.validate(fromImporterValidation(validation));
+}
+
+function validateMultipleResults(parser, validations) {
+  return validateMultiple(validations.map(fromImporterValidation), parser);
+}
+
+export {
+  toInvalid,
+  toValid,
+  toError,
+  toValidTransformation,
+  toErrorTransformation,
+  fromImporterValidation,
+  validateMultiple,
+  validateResult,
+  validateMultipleResults,
+}
+/* No side effect */

package/src/examples/Example.res

@@ -0,0 +1,26 @@
+open FastCSV
+open FastCSV_Helpers
+
+parseFile(
+  ~path="x.csv",
+  ~options={
+    Options.headers: Bool(true),
+    delimiter: ";",
+    //~trim=true,
+    //~discardUnmappedColumns=false, ~strictColumnHandling=true,
+  },
+)
+->transform((row, cb) => {
+  Dict.delete(row, "")
+  cb->toValidTransformation(row)
+})
+->onData(row => Console.log2("parsed line:", row))
+->onInvalid((row, rowNumber, reason) =>
+  switch reason {
+  | None => Console.log2(`line (${rowNumber->Int.toString}) has too many/view records:`, row)
+  | Some(reason) => Console.log2(`line (${rowNumber->Int.toString}) is invalid: ${reason}`, row)
+  }
+)
+->onError(err => Console.log2("error during parsing:", err->JsExn.message))
+->onEnd(rowCount => Console.log(`${rowCount->Int.toString} rows parsed`))
+->ignore

package/src/examples/x.csv

@@ -0,0 +1,4 @@
+1;2;3
+a;b;c
+d;e;f
+g;h;i