cisv 0.4.8 → 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,8 +5,11 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <algorithm>
 #include <chrono>
 #include <cstdint>
+#include <climits>
+#include <cmath>
 
 namespace {
 
@@ -46,6 +49,126 @@ static void ValidateSingleCharOption(
     *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
@@ -144,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;
             }
@@ -589,7 +712,7 @@ public:
     }
 
     CisvParser(const Napi::CallbackInfo &info) : Napi::ObjectWrap<CisvParser>(info) {
-        rc_ = new RowCollector();
+        rc_ = nullptr;
         parser_ = nullptr;
         parse_time_ = 0;
         total_bytes_ = 0;
@@ -609,6 +732,8 @@ public:
             ApplyConfigFromObject(options);
         }
 
+        rc_ = new RowCollector();
+
         // Set callbacks
         config_.field_cb = field_cb;
         config_.row_cb = row_cb;
@@ -623,51 +748,9 @@ public:
     // Apply configuration from JavaScript object
     void ApplyConfigFromObject(Napi::Object options) {
         Napi::Env env = options.Env();
-
-        // Delimiter
-        ValidateSingleCharOption(env, options, "delimiter", &config_.delimiter);
-
-        // Quote character
-        ValidateSingleCharOption(env, options, "quote", &config_.quote);
-
-        // Escape character
-        ValidateSingleCharOption(env, options, "escape", &config_.escape, true);
-
-        // Comment character
-        ValidateSingleCharOption(env, options, "comment", &config_.comment, true);
-
-        // 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();
-        }
+        cisv_config next = config_;
+        ApplyConfigOptions(env, options, &next);
+        config_ = next;
     }
 
     // Set configuration after creation
@@ -817,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)));
             }
@@ -843,14 +938,14 @@ public:
             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);
     }
@@ -1074,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 {
@@ -1185,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 {
@@ -1355,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();
 }
@@ -1385,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();
     }
@@ -1515,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;
@@ -1590,25 +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
-            ValidateSingleCharOption(env, options, "delimiter", &config.delimiter);
-            ValidateSingleCharOption(env, options, "quote", &config.quote);
-            ValidateSingleCharOption(env, options, "comment", &config.comment, true);
-
-            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);
@@ -1836,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, "0.4.8"));
+    exports.Set("version", Napi::String::New(env, "0.4.9"));
 
     // Add transform type constants
     Napi::Object transformTypes = Napi::Object::New(env);
@@ -1845,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'
   }
@@ -88,11 +87,11 @@ declare module 'cisv' {
     parseParallel(path: string, numThreads?: number): Promise<string[][]>;
 
     /**
-     * Parse CSV string content
-     * @param content CSV string content
+     * 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.8",
+  "version": "0.4.9",
   "description": "The csv parser on steroids.",
   "author": "sanix<s4nixd@gmail.com>",
   "main": "./build/Release/cisv.node",