cisv 0.4.7 → 0.4.9

package/README.md

@@ -83,7 +83,6 @@ Built-in transform names:
 - `trim`
 - `to_int` (or `int`)
 - `to_float` (or `float`)
-- `hash_sha256` (or `sha256`)
 - `base64_encode` (or `base64`)
 
 ## Examples

package/binding.gyp

@@ -21,7 +21,6 @@
       "cflags_cc!": [ "-fno-exceptions" ],
       "cflags_cc": ["-O3"],
       "defines": [
-        "NAPI_DISABLE_CPP_EXCEPTIONS",
         "NAPI_VERSION=6"
       ],
       "conditions": [

package/cisv/cisv_addon.cc

@@ -5,11 +5,170 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <algorithm>
 #include <chrono>
 #include <cstdint>
+#include <climits>
+#include <cmath>
 
 namespace {
 
+static bool isInvalidConfigChar(char c) {
+    return c == '\0' || c == '\n' || c == '\r';
+}
+
+static void ValidateSingleCharOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    char *target,
+    bool allow_null = false
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (allow_null && (value.IsNull() || value.IsUndefined())) {
+        *target = 0;
+        return;
+    }
+
+    if (!value.IsString()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a string");
+    }
+
+    std::string raw = value.As<Napi::String>();
+    if (raw.size() != 1) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be exactly 1 character");
+    }
+    if (isInvalidConfigChar(raw[0])) {
+        throw Napi::TypeError::New(env, std::string("Invalid ") + option_name + " character");
+    }
+
+    *target = raw[0];
+}
+
+static double MaxJsSafeInteger() {
+    return 9007199254740991.0;
+}
+
+static bool IsWholeNumber(double value) {
+    return std::isfinite(value) && std::floor(value) == value;
+}
+
+static void ApplyBooleanOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    bool *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (!value.IsBoolean()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a boolean");
+    }
+
+    *target = value.As<Napi::Boolean>();
+}
+
+static void ApplySizeOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    size_t *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (value.IsNull() || value.IsUndefined()) {
+        *target = 0;
+        return;
+    }
+    if (!value.IsNumber()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a number");
+    }
+
+    double raw = value.As<Napi::Number>().DoubleValue();
+    double max_value = static_cast<double>(SIZE_MAX);
+    if (!IsWholeNumber(raw) || raw < 0.0 || raw > max_value || raw > MaxJsSafeInteger()) {
+        throw Napi::RangeError::New(env, std::string(option_name) + " is out of range");
+    }
+
+    *target = static_cast<size_t>(raw);
+}
+
+static void ApplyLineOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    int *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (value.IsNull() || value.IsUndefined()) {
+        *target = 0;
+        return;
+    }
+    if (!value.IsNumber()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a number");
+    }
+
+    double raw = value.As<Napi::Number>().DoubleValue();
+    if (!IsWholeNumber(raw) || raw < 0.0 || raw > static_cast<double>(INT_MAX)) {
+        throw Napi::RangeError::New(env, std::string(option_name) + " is out of range");
+    }
+
+    *target = static_cast<int>(raw);
+}
+
+static void ValidateConfigSemantics(Napi::Env env, const cisv_config &config) {
+    if (config.delimiter == config.quote) {
+        throw Napi::TypeError::New(env, "delimiter and quote cannot be the same");
+    }
+    if (config.escape != '\0' && config.escape == config.delimiter) {
+        throw Napi::TypeError::New(env, "escape and delimiter cannot be the same");
+    }
+    if (config.escape != '\0' && config.escape == config.quote) {
+        throw Napi::TypeError::New(env, "escape and quote cannot be the same");
+    }
+    if (config.comment != '\0' &&
+        (config.comment == config.delimiter || config.comment == config.quote || config.comment == config.escape)) {
+        throw Napi::TypeError::New(env, "comment cannot conflict with delimiter, quote, or escape");
+    }
+
+    int effective_from = config.from_line > 0 ? config.from_line : 1;
+    if (config.to_line != 0 && config.to_line < effective_from) {
+        throw Napi::RangeError::New(env, "toLine must be >= fromLine");
+    }
+}
+
+static void ApplyConfigOptions(Napi::Env env, const Napi::Object &options, cisv_config *config) {
+    ValidateSingleCharOption(env, options, "delimiter", &config->delimiter);
+    ValidateSingleCharOption(env, options, "quote", &config->quote);
+    ValidateSingleCharOption(env, options, "escape", &config->escape, true);
+    ValidateSingleCharOption(env, options, "comment", &config->comment, true);
+
+    ApplyBooleanOption(env, options, "skipEmptyLines", &config->skip_empty_lines);
+    ApplyBooleanOption(env, options, "trim", &config->trim);
+    ApplyBooleanOption(env, options, "relaxed", &config->relaxed);
+    ApplyBooleanOption(env, options, "skipLinesWithError", &config->skip_lines_with_error);
+
+    ApplySizeOption(env, options, "maxRowSize", &config->max_row_size);
+    ApplyLineOption(env, options, "fromLine", &config->from_line);
+    ApplyLineOption(env, options, "toLine", &config->to_line);
+
+    ValidateConfigSemantics(env, *config);
+}
+
 // =============================================================================
 // SECURITY: UTF-8 validation to prevent V8 crashes on invalid input
 // Invalid UTF-8 data can cause Napi::String::New to throw or crash
@@ -108,7 +267,7 @@ static napi_value SafeNewStringValue(napi_env env, const char* data, size_t len)
             if (napi_create_string_latin1(env, data, len, &short_value) == napi_ok && short_value) {
                 return short_value;
             }
-        } else {
+        } else if (isValidUtf8(data, len)) {
             if (napi_create_string_utf8(env, data, len, &short_value) == napi_ok && short_value) {
                 return short_value;
             }
@@ -339,6 +498,69 @@ static void error_cb(void *user, int line, const char *msg) {
     fprintf(stderr, "CSV Parse Error at line %d: %s\n", line, msg);
 }
 
+static bool validateNumThreads(int num_threads, std::string &error) {
+    if (num_threads < 0) {
+        error = "numThreads must be >= 0";
+        return false;
+    }
+    return true;
+}
+
+static bool collectParallelRows(
+    cisv_result_t **results,
+    int result_count,
+    std::vector<std::vector<std::string>> &rows,
+    std::string &error
+) {
+    size_t total_rows = 0;
+    for (int chunk = 0; chunk < result_count; chunk++) {
+        cisv_result_t *result = results[chunk];
+        if (!result) {
+            continue;
+        }
+        if (result->error_code != 0) {
+            error = result->error_message[0] ? result->error_message : "parse error";
+            return false;
+        }
+        total_rows += result->row_count;
+    }
+
+    rows.clear();
+    rows.reserve(total_rows);
+
+    for (int chunk = 0; chunk < result_count; chunk++) {
+        cisv_result_t *result = results[chunk];
+        if (!result) {
+            continue;
+        }
+
+        for (size_t i = 0; i < result->row_count; i++) {
+            cisv_row_t *row = &result->rows[i];
+            std::vector<std::string> out_row;
+            out_row.reserve(row->field_count);
+            for (size_t j = 0; j < row->field_count; j++) {
+                out_row.emplace_back(row->fields[j], row->field_lengths[j]);
+            }
+            rows.emplace_back(std::move(out_row));
+        }
+    }
+
+    return true;
+}
+
+static Napi::Array rowsToJsArray(Napi::Env env, const std::vector<std::vector<std::string>> &rows) {
+    Napi::Array out = Napi::Array::New(env, rows.size());
+    for (size_t i = 0; i < rows.size(); i++) {
+        Napi::Array row = Napi::Array::New(env, rows[i].size());
+        for (size_t j = 0; j < rows[i].size(); j++) {
+            const std::string &field = rows[i][j];
+            row[j] = SafeNewString(env, field.c_str(), field.length());
+        }
+        out[i] = row;
+    }
+    return out;
+}
+
 class ParseFileWorker final : public Napi::AsyncWorker {
 public:
     ParseFileWorker(
@@ -383,19 +605,57 @@ public:
     }
 
     void OnOK() override {
-        Napi::Env env = Env();
-        Napi::Array out = Napi::Array::New(env, rows_.size());
-
-        for (size_t i = 0; i < rows_.size(); i++) {
-            Napi::Array row = Napi::Array::New(env, rows_[i].size());
-            for (size_t j = 0; j < rows_[i].size(); j++) {
-                const std::string &field = rows_[i][j];
-                row[j] = SafeNewString(env, field.c_str(), field.length());
-            }
-            out[i] = row;
+        deferred_.Resolve(rowsToJsArray(Env(), rows_));
+    }
+
+    void OnError(const Napi::Error &e) override {
+        deferred_.Reject(e.Value());
+    }
+
+private:
+    std::string path_;
+    cisv_config config_;
+    Napi::Promise::Deferred deferred_;
+    std::vector<std::vector<std::string>> rows_;
+};
+
+class ParseFileParallelWorker final : public Napi::AsyncWorker {
+public:
+    ParseFileParallelWorker(
+        Napi::Env env,
+        std::string path,
+        cisv_config config,
+        int num_threads,
+        Napi::Promise::Deferred deferred
+    ) : Napi::AsyncWorker(env),
+        path_(std::move(path)),
+        config_(config),
+        num_threads_(num_threads),
+        deferred_(deferred) {}
+
+    void Execute() override {
+        if (!validateNumThreads(num_threads_, error_)) {
+            SetError(error_);
+            return;
+        }
+
+        int result_count = 0;
+        cisv_result_t **results = cisv_parse_file_parallel(path_.c_str(), &config_, num_threads_, &result_count);
+        if (!results) {
+            SetError("parse error: " + std::string(strerror(errno)));
+            return;
+        }
+
+        bool ok = collectParallelRows(results, result_count, rows_, error_);
+        cisv_results_free(results, result_count);
+
+        if (!ok) {
+            SetError(error_);
         }
+    }
 
-        deferred_.Resolve(out);
+    void OnOK() override {
+        deferred_.Resolve(rowsToJsArray(Env(), rows_));
     }
 
     void OnError(const Napi::Error &e) override {
@@ -405,8 +665,10 @@ public:
 private:
     std::string path_;
     cisv_config config_;
+    int num_threads_;
     Napi::Promise::Deferred deferred_;
     std::vector<std::vector<std::string>> rows_;
+    std::string error_;
 };
 
 } // namespace
@@ -416,7 +678,9 @@ public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports) {
         Napi::Function func = DefineClass(env, "cisvParser", {
             InstanceMethod("parseSync", &CisvParser::ParseSync),
+            InstanceMethod("parseSyncParallel", &CisvParser::ParseSyncParallel),
             InstanceMethod("parse", &CisvParser::ParseAsync),
+            InstanceMethod("parseParallel", &CisvParser::ParseParallel),
             InstanceMethod("parseString", &CisvParser::ParseString),
             InstanceMethod("write", &CisvParser::Write),
             InstanceMethod("end", &CisvParser::End),
@@ -448,7 +712,8 @@ public:
     }
 
     CisvParser(const Napi::CallbackInfo &info) : Napi::ObjectWrap<CisvParser>(info) {
-        rc_ = new RowCollector();
+        rc_ = nullptr;
+        parser_ = nullptr;
         parse_time_ = 0;
         total_bytes_ = 0;
         is_destroyed_ = false;
@@ -467,14 +732,13 @@ public:
             ApplyConfigFromObject(options);
         }
 
+        rc_ = new RowCollector();
+
         // Set callbacks
         config_.field_cb = field_cb;
         config_.row_cb = row_cb;
         config_.error_cb = error_cb;
         config_.user = rc_;
-
-        // Create parser with configuration
-        parser_ = cisv_parser_create_with_config(&config_);
     }
 
     ~CisvParser() {
@@ -483,84 +747,10 @@ public:
 
     // Apply configuration from JavaScript object
     void ApplyConfigFromObject(Napi::Object options) {
-        // Delimiter
-        if (options.Has("delimiter")) {
-            Napi::Value delim = options.Get("delimiter");
-            if (delim.IsString()) {
-                std::string delim_str = delim.As<Napi::String>();
-                if (!delim_str.empty()) {
-                    config_.delimiter = delim_str[0];
-                }
-            }
-        }
-
-        // Quote character
-        if (options.Has("quote")) {
-            Napi::Value quote = options.Get("quote");
-            if (quote.IsString()) {
-                std::string quote_str = quote.As<Napi::String>();
-                if (!quote_str.empty()) {
-                    config_.quote = quote_str[0];
-                }
-            }
-        }
-
-        // Escape character
-        if (options.Has("escape")) {
-            Napi::Value escape = options.Get("escape");
-            if (escape.IsString()) {
-                std::string escape_str = escape.As<Napi::String>();
-                if (!escape_str.empty()) {
-                    config_.escape = escape_str[0];
-                }
-            } else if (escape.IsNull() || escape.IsUndefined()) {
-                config_.escape = 0; // RFC4180 style
-            }
-        }
-
-        // Comment character
-        if (options.Has("comment")) {
-            Napi::Value comment = options.Get("comment");
-            if (comment.IsString()) {
-                std::string comment_str = comment.As<Napi::String>();
-                if (!comment_str.empty()) {
-                    config_.comment = comment_str[0];
-                }
-            }
-        }
-
-        // Boolean options
-        if (options.Has("skipEmptyLines")) {
-            config_.skip_empty_lines = options.Get("skipEmptyLines").As<Napi::Boolean>();
-        }
-
-        if (options.Has("trim")) {
-            config_.trim = options.Get("trim").As<Napi::Boolean>();
-        }
-
-        if (options.Has("relaxed")) {
-            config_.relaxed = options.Get("relaxed").As<Napi::Boolean>();
-        }
-
-        if (options.Has("skipLinesWithError")) {
-            config_.skip_lines_with_error = options.Get("skipLinesWithError").As<Napi::Boolean>();
-        }
-
-        // Numeric options
-        if (options.Has("maxRowSize")) {
-            Napi::Value val = options.Get("maxRowSize");
-            if (!val.IsNull() && !val.IsUndefined()) {
-                config_.max_row_size = val.As<Napi::Number>().Uint32Value();
-            }
-        }
-
-        if (options.Has("fromLine")) {
-            config_.from_line = options.Get("fromLine").As<Napi::Number>().Int32Value();
-        }
-
-        if (options.Has("toLine")) {
-            config_.to_line = options.Get("toLine").As<Napi::Number>().Int32Value();
-        }
+        Napi::Env env = options.Env();
+        cisv_config next = config_;
+        ApplyConfigOptions(env, options, &next);
+        config_ = next;
     }
 
     // Set configuration after creation
@@ -578,17 +768,12 @@ public:
         Napi::Object options = info[0].As<Napi::Object>();
         ApplyConfigFromObject(options);
 
-        // Recreate parser with new configuration
+        // Recreate the streaming parser only if it has already been instantiated.
         if (parser_) {
             cisv_parser_destroy(parser_);
+            parser_ = nullptr;
+            ensureParser(env);
         }
-
-        config_.field_cb = field_cb;
-        config_.row_cb = row_cb;
-        config_.error_cb = error_cb;
-        config_.user = rc_;
-
-        parser_ = cisv_parser_create_with_config(&config_);
     }
 
     // Get current configuration
@@ -692,6 +877,7 @@ public:
         } else {
             // Set environment for JS transforms
             rc_->env = env;
+            ensureParser(env);
             result = cisv_parser_parse_file(parser_, path.c_str());
             // Clear the environment reference after parsing
             rc_->env = nullptr;
@@ -714,16 +900,28 @@ public:
             throw Napi::Error::New(env, "Parser has been destroyed");
         }
 
-        if (info.Length() != 1 || !info[0].IsString()) {
-            throw Napi::TypeError::New(env, "Expected CSV string");
+        if (info.Length() != 1 || (!info[0].IsString() && !info[0].IsBuffer())) {
+            throw Napi::TypeError::New(env, "Expected CSV string or Buffer");
         }
 
-        std::string content = info[0].As<Napi::String>();
+        const char *content_data = nullptr;
+        size_t content_len = 0;
+        std::string content_storage;
+
+        if (info[0].IsBuffer()) {
+            auto buffer = info[0].As<Napi::Buffer<char>>();
+            content_data = buffer.Data();
+            content_len = buffer.Length();
+        } else {
+            content_storage = info[0].As<Napi::String>();
+            content_data = content_storage.data();
+            content_len = content_storage.size();
+        }
 
         resetRowState();
 
         if (!hasTransforms()) {
-            cisv_result_t *batch = cisv_parse_string_batch(content.c_str(), content.length(), &config_);
+            cisv_result_t *batch = cisv_parse_string_batch(content_data, content_len, &config_);
             if (!batch) {
                 throw Napi::Error::New(env, "parse error: " + std::string(strerror(errno)));
             }
@@ -737,20 +935,68 @@ public:
         } else {
             // Set environment for JS transforms
             rc_->env = env;
+            ensureParser(env);
 
             // Write the string content as chunks
-            cisv_parser_write(parser_, (const uint8_t*)content.c_str(), content.length());
+            cisv_parser_write(parser_, reinterpret_cast<const uint8_t*>(content_data), content_len);
             cisv_parser_end(parser_);
 
             // Clear the environment reference after parsing
             rc_->env = nullptr;
         }
 
-        total_bytes_ = content.length();
+        total_bytes_ = content_len;
 
         return drainRows(env);
     }
 
+    Napi::Value ParseSyncParallel(const Napi::CallbackInfo &info) {
+        Napi::Env env = info.Env();
+
+        if (is_destroyed_) {
+            throw Napi::Error::New(env, "Parser has been destroyed");
+        }
+
+        if (info.Length() < 1 || !info[0].IsString()) {
+            throw Napi::TypeError::New(env, "Expected file path string");
+        }
+
+        int num_threads = 0;
+        if (info.Length() > 1 && !info[1].IsUndefined() && !info[1].IsNull()) {
+            if (!info[1].IsNumber()) {
+                throw Napi::TypeError::New(env, "numThreads must be a number");
+            }
+            num_threads = info[1].As<Napi::Number>().Int32Value();
+        }
+
+        std::string validation_error;
+        if (!validateNumThreads(num_threads, validation_error)) {
+            throw Napi::TypeError::New(env, validation_error);
+        }
+
+        std::string path = info[0].As<Napi::String>().Utf8Value();
+        int result_count = 0;
+        cisv_result_t **results = cisv_parse_file_parallel(
+            path.c_str(),
+            &config_,
+            num_threads,
+            &result_count);
+        if (!results) {
+            throw Napi::Error::New(env, "parse error: " + std::string(strerror(errno)));
+        }
+
+        std::vector<std::vector<std::string>> rows;
+        std::string error;
+        bool ok = collectParallelRows(results, result_count, rows, error);
+        cisv_results_free(results, result_count);
+
+        if (!ok) {
+            throw Napi::Error::New(env, error);
+        }
+
+        return rowsToJsArray(env, rows);
+    }
+
     // Write chunk for streaming
     void Write(const Napi::CallbackInfo &info) {
         Napi::Env env = info.Env();
@@ -813,6 +1059,7 @@ public:
             stream_buffering_active_ = false;
         }
 
+        ensureParser(env);
         cisv_parser_write(parser_, chunk_data, chunk_size);
         total_bytes_ += chunk_size;
     }
@@ -847,6 +1094,7 @@ public:
             stream_buffering_active_ = false;
         }
 
+        ensureParser(info.Env());
         cisv_parser_end(parser_);
         // Clear the environment reference after ending to prevent stale references
         rc_->env = nullptr;
@@ -921,8 +1169,6 @@ public:
                 type = TRANSFORM_TO_INT;
             } else if (transform_type == "to_float" || transform_type == "float") {
                 type = TRANSFORM_TO_FLOAT;
-            } else if (transform_type == "hash_sha256" || transform_type == "sha256") {
-                type = TRANSFORM_HASH_SHA256;
             } else if (transform_type == "base64_encode" || transform_type == "base64") {
                 type = TRANSFORM_BASE64_ENCODE;
             } else {
@@ -1032,8 +1278,6 @@ Napi::Value TransformByName(const Napi::CallbackInfo &info) {
             type = TRANSFORM_TO_INT;
         } else if (transform_type == "to_float" || transform_type == "float") {
             type = TRANSFORM_TO_FLOAT;
-        } else if (transform_type == "hash_sha256" || transform_type == "sha256") {
-            type = TRANSFORM_HASH_SHA256;
         } else if (transform_type == "base64_encode" || transform_type == "base64") {
             type = TRANSFORM_BASE64_ENCODE;
         } else {
@@ -1202,18 +1446,28 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
 
     std::string field_name = info[0].As<Napi::String>();
 
+    int field_index = -1;
+
     // Remove from JavaScript transforms by finding the field index
     if (rc_->pipeline && rc_->pipeline->header_fields) {
         for (size_t i = 0; i < rc_->pipeline->header_count; i++) {
             if (strcmp(rc_->pipeline->header_fields[i], field_name.c_str()) == 0) {
-                rc_->js_transforms.erase(i);
+                field_index = static_cast<int>(i);
+                auto it = rc_->js_transforms.find(field_index);
+                if (it != rc_->js_transforms.end()) {
+                    if (!it->second.IsEmpty()) {
+                        it->second.Reset();
+                    }
+                    rc_->js_transforms.erase(it);
+                }
                 break;
             }
         }
     }
 
-    // TODO: Implement removal of C transforms by name in cisv_transformer.c
-    // For now, this only removes JS transforms
+    if (field_index >= 0 && rc_->pipeline) {
+        cisv_transform_pipeline_remove_field(rc_->pipeline, field_index);
+    }
 
     return info.This();
 }
@@ -1232,10 +1486,17 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         int field_index = info[0].As<Napi::Number>().Int32Value();
 
         // Remove from JavaScript transforms
-        rc_->js_transforms.erase(field_index);
+        auto it = rc_->js_transforms.find(field_index);
+        if (it != rc_->js_transforms.end()) {
+            if (!it->second.IsEmpty()) {
+                it->second.Reset();
+            }
+            rc_->js_transforms.erase(it);
+        }
 
-        // TODO: Implement removal of C transforms in cisv_transformer.c
-        // For now, this only removes JS transforms
+        if (rc_->pipeline) {
+            cisv_transform_pipeline_remove_field(rc_->pipeline, field_index);
+        }
 
         return info.This();
     }
@@ -1306,6 +1567,43 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         return deferred.Promise();
     }
 
+    Napi::Value ParseParallel(const Napi::CallbackInfo &info) {
+        Napi::Env env = info.Env();
+
+        if (is_destroyed_) {
+            throw Napi::Error::New(env, "Parser has been destroyed");
+        }
+
+        if (info.Length() < 1 || !info[0].IsString()) {
+            throw Napi::TypeError::New(env, "Expected file path string");
+        }
+
+        int num_threads = 0;
+        if (info.Length() > 1 && !info[1].IsUndefined() && !info[1].IsNull()) {
+            if (!info[1].IsNumber()) {
+                throw Napi::TypeError::New(env, "numThreads must be a number");
+            }
+            num_threads = info[1].As<Napi::Number>().Int32Value();
+        }
+
+        auto deferred = Napi::Promise::Deferred::New(env);
+        cisv_config worker_config = config_;
+        worker_config.field_cb = nullptr;
+        worker_config.row_cb = nullptr;
+        worker_config.error_cb = nullptr;
+        worker_config.user = nullptr;
+
+        auto *worker = new ParseFileParallelWorker(
+            env,
+            info[0].As<Napi::String>().Utf8Value(),
+            worker_config,
+            num_threads,
+            deferred);
+        worker->Queue();
+
+        return deferred.Promise();
+    }
+
     // Get information about registered transforms
     Napi::Value GetTransformInfo(const Napi::CallbackInfo &info) {
         Napi::Env env = info.Env();
@@ -1325,16 +1623,29 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         result.Set("jsTransformCount", Napi::Number::New(env, js_transform_count));
 
         // List field indices with transforms
-        Napi::Array fields = Napi::Array::New(env);
-        size_t idx = 0;
+        std::vector<int> field_indices;
+        auto add_field_index = [&field_indices](int field_index) {
+            if (std::find(field_indices.begin(), field_indices.end(), field_index) == field_indices.end()) {
+                field_indices.push_back(field_index);
+            }
+        };
 
-        // Add JS transform field indices
+        if (rc_ && rc_->pipeline) {
+            for (size_t i = 0; i < rc_->pipeline->count; i++) {
+                add_field_index(rc_->pipeline->transforms[i].field_index);
+            }
+        }
         if (rc_) {
             for (const auto& pair : rc_->js_transforms) {
-                fields[idx++] = Napi::Number::New(env, pair.first);
+                add_field_index(pair.first);
             }
         }
 
+        Napi::Array fields = Napi::Array::New(env, field_indices.size());
+        for (size_t i = 0; i < field_indices.size(); i++) {
+            fields[i] = Napi::Number::New(env, field_indices[i]);
+        }
+
         result.Set("fieldIndices", fields);
 
         return result;
@@ -1400,36 +1711,13 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         cisv_config_init(&config);
 
         // Apply configuration if provided
+        if (info.Length() > 1 && !info[1].IsNull() && !info[1].IsUndefined() && !info[1].IsObject()) {
+            throw Napi::TypeError::New(env, "Config must be an object");
+        }
+
         if (info.Length() > 1 && info[1].IsObject()) {
             Napi::Object options = info[1].As<Napi::Object>();
-
-            // Apply same configuration parsing logic
-            if (options.Has("delimiter")) {
-                std::string delim = options.Get("delimiter").As<Napi::String>();
-                if (!delim.empty()) config.delimiter = delim[0];
-            }
-
-            if (options.Has("quote")) {
-                std::string quote = options.Get("quote").As<Napi::String>();
-                if (!quote.empty()) config.quote = quote[0];
-            }
-
-            if (options.Has("comment")) {
-                std::string comment = options.Get("comment").As<Napi::String>();
-                if (!comment.empty()) config.comment = comment[0];
-            }
-
-            if (options.Has("skipEmptyLines")) {
-                config.skip_empty_lines = options.Get("skipEmptyLines").As<Napi::Boolean>();
-            }
-
-            if (options.Has("fromLine")) {
-                config.from_line = options.Get("fromLine").As<Napi::Number>().Int32Value();
-            }
-
-            if (options.Has("toLine")) {
-                config.to_line = options.Get("toLine").As<Napi::Number>().Int32Value();
-            }
+            ApplyConfigOptions(env, options, &config);
         }
 
         size_t count = cisv_parser_count_rows_with_config(path.c_str(), &config);
@@ -1532,6 +1820,22 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
     }
 
 private:
+    void ensureParser(Napi::Env env) {
+        if (parser_) {
+            return;
+        }
+
+        config_.field_cb = field_cb;
+        config_.row_cb = row_cb;
+        config_.error_cb = error_cb;
+        config_.user = rc_;
+
+        parser_ = cisv_parser_create_with_config(&config_);
+        if (!parser_) {
+            throw Napi::Error::New(env, "Failed to create parser");
+        }
+    }
+
     void clearBatchResult() {
         if (batch_result_) {
             cisv_result_free(batch_result_);
@@ -1559,6 +1863,7 @@ private:
         if (pending_stream_.empty()) {
             return;
         }
+        ensureParser(Env());
         cisv_parser_write(
             parser_,
             reinterpret_cast<const uint8_t*>(pending_stream_.data()),
@@ -1640,7 +1945,7 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
     CisvParser::Init(env, exports);
 
     // Add version info
-    exports.Set("version", Napi::String::New(env, "1.1.0"));
+    exports.Set("version", Napi::String::New(env, "0.4.9"));
 
     // Add transform type constants
     Napi::Object transformTypes = Napi::Object::New(env);
@@ -1649,7 +1954,6 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
     transformTypes.Set("TRIM", Napi::String::New(env, "trim"));
     transformTypes.Set("TO_INT", Napi::String::New(env, "to_int"));
     transformTypes.Set("TO_FLOAT", Napi::String::New(env, "to_float"));
-    transformTypes.Set("HASH_SHA256", Napi::String::New(env, "hash_sha256"));
     transformTypes.Set("BASE64_ENCODE", Napi::String::New(env, "base64_encode"));
     exports.Set("TransformType", transformTypes);
 

package/cisv/types/cisv.d.ts

@@ -8,7 +8,6 @@ declare module 'cisv' {
     TRIM = 'trim',
     TO_INT = 'to_int',
     TO_FLOAT = 'to_float',
-    HASH_SHA256 = 'hash_sha256',
     BASE64_ENCODE = 'base64_encode',
     CUSTOM = 'custom'
   }
@@ -64,6 +63,14 @@ declare module 'cisv' {
      */
     parseSync(path: string): string[][];
 
+    /**
+     * Parse CSV file synchronously using multiple worker threads.
+     * @param path Path to CSV file
+     * @param numThreads Number of threads to use (0 = auto-detect)
+     * @returns Array of rows with string values
+     */
+    parseSyncParallel(path: string, numThreads?: number): string[][];
+
     /**
      * Parse CSV file asynchronously
      * @param path Path to CSV file
@@ -72,11 +79,19 @@ declare module 'cisv' {
     parse(path: string): Promise<string[][]>;
 
     /**
-     * Parse CSV string content
-     * @param content CSV string content
+     * Parse CSV file asynchronously using multiple worker threads.
+     * @param path Path to CSV file
+     * @param numThreads Number of threads to use (0 = auto-detect)
+     * @returns Promise resolving to array of rows
+     */
+    parseParallel(path: string, numThreads?: number): Promise<string[][]>;
+
+    /**
+     * Parse CSV string or Buffer content
+     * @param content CSV content as string or Buffer
      * @returns Array of rows with string values
      */
-    parseString(content: string): string[][];
+    parseString(content: Buffer | string): string[][];
 
     /**
      * Write chunk of CSV data (for streaming)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cisv",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "The csv parser on steroids.",
   "author": "sanix<s4nixd@gmail.com>",
   "main": "./build/Release/cisv.node",