deukpack 1.0.0 → 1.0.2

package/native/cpp/src/compact_writer.cpp

@@ -0,0 +1,113 @@
+/**
+ * DeukPack Compact Writer
+ * High-performance compact protocol serialization
+ */
+
+#include "compact_writer.h"
+#include <cstring>
+
+namespace deukpack
+{
+
+    CompactWriter::CompactWriter(size_t initialSize)
+        : position_(0)
+    {
+        currentBuffer_.resize(initialSize);
+    }
+
+    void CompactWriter::WriteByte(uint8_t value)
+    {
+        EnsureCapacity(1);
+        currentBuffer_[position_++] = value;
+    }
+
+    void CompactWriter::WriteVarInt(int32_t value)
+    {
+        while (value >= 0x80)
+        {
+            WriteByte((value & 0x7F) | 0x80);
+            value >>= 7;
+        }
+        WriteByte(value & 0x7F);
+    }
+
+    void CompactWriter::WriteString(const std::string &value)
+    {
+        WriteVarInt(static_cast<int32_t>(value.length()));
+        WriteBytes(reinterpret_cast<const uint8_t *>(value.c_str()), value.length());
+    }
+
+    void CompactWriter::WriteBytes(const uint8_t *data, size_t length)
+    {
+        EnsureCapacity(length);
+        std::memcpy(&currentBuffer_[position_], data, length);
+        position_ += length;
+    }
+
+    std::vector<uint8_t> CompactWriter::GetBuffer()
+    {
+        FlushCurrentBuffer();
+
+        if (buffers_.empty())
+        {
+            return std::vector<uint8_t>();
+        }
+
+        if (buffers_.size() == 1)
+        {
+            return std::move(buffers_[0]);
+        }
+
+        // Calculate total size
+        size_t totalSize = 0;
+        for (const auto &buffer : buffers_)
+        {
+            totalSize += buffer.size();
+        }
+
+        // Concatenate all buffers
+        std::vector<uint8_t> result;
+        result.reserve(totalSize);
+
+        for (const auto &buffer : buffers_)
+        {
+            result.insert(result.end(), buffer.begin(), buffer.end());
+        }
+
+        return result;
+    }
+
+    void CompactWriter::Reset()
+    {
+        buffers_.clear();
+        position_ = 0;
+        currentBuffer_.resize(1024);
+    }
+
+    void CompactWriter::EnsureCapacity(size_t needed)
+    {
+        if (position_ + needed > currentBuffer_.size())
+        {
+            FlushCurrentBuffer();
+            AllocateNewBuffer(std::max(needed * 2, static_cast<size_t>(1024)));
+        }
+    }
+
+    void CompactWriter::FlushCurrentBuffer()
+    {
+        if (position_ > 0)
+        {
+            std::vector<uint8_t> buffer(position_);
+            std::memcpy(buffer.data(), currentBuffer_.data(), position_);
+            buffers_.push_back(std::move(buffer));
+            position_ = 0;
+        }
+    }
+
+    void CompactWriter::AllocateNewBuffer(size_t size)
+    {
+        currentBuffer_.resize(size);
+        position_ = 0;
+    }
+
+} // namespace deukpack

package/native/cpp/src/thrift_engine.cpp

@@ -0,0 +1,380 @@
+/**
+ * DeukPack Native C++ Implementation
+ * High-performance Thrift engine
+ */
+
+#include <napi.h>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include <chrono>
+#include "thrift_engine.h"
+#include "binary_writer.h"
+
+using namespace deukpack;
+
+// ThriftEngine implementation
+class ThriftEngine::Impl
+{
+public:
+    Impl() : memoryUsage_(0) {}
+
+    ThriftAST ParseFiles(const std::vector<std::string> &filePaths)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        ThriftAST ast;
+        // TODO: Implement actual parsing logic
+        // For now, return empty AST
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        parseTime_ = duration.count();
+
+        return ast;
+    }
+
+    std::vector<uint8_t> Serialize(const std::unordered_map<std::string, std::string> &data,
+                                   const SerializationOptions &options)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        BinaryWriter writer(options.endianness == Endianness::LITTLE_ENDIAN ? Endianness::LITTLE_ENDIAN : Endianness::BIG_ENDIAN);
+
+        // Simple serialization for demonstration
+        writer.WriteI32(static_cast<int32_t>(data.size()));
+        for (const auto &pair : data)
+        {
+            writer.WriteString(pair.first);
+            writer.WriteString(pair.second);
+        }
+
+        auto result = writer.GetBuffer();
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        serializeTime_ = duration.count();
+
+        return result;
+    }
+
+    std::unordered_map<std::string, std::string> Deserialize(const std::vector<uint8_t> &data,
+                                                             const SerializationOptions &options)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        std::unordered_map<std::string, std::string> result;
+
+        // Simple deserialization for demonstration
+        if (data.size() >= 4)
+        {
+            int32_t count = *reinterpret_cast<const int32_t *>(data.data());
+            size_t offset = 4;
+
+            for (int32_t i = 0; i < count && offset < data.size(); i++)
+            {
+                if (offset + 4 > data.size())
+                    break;
+
+                int32_t keyLen = *reinterpret_cast<const int32_t *>(data.data() + offset);
+                offset += 4;
+
+                if (offset + keyLen > data.size())
+                    break;
+                std::string key(data.data() + offset, data.data() + offset + keyLen);
+                offset += keyLen;
+
+                if (offset + 4 > data.size())
+                    break;
+                int32_t valueLen = *reinterpret_cast<const int32_t *>(data.data() + offset);
+                offset += 4;
+
+                if (offset + valueLen > data.size())
+                    break;
+                std::string value(data.data() + offset, data.data() + offset + valueLen);
+                offset += valueLen;
+
+                result[key] = value;
+            }
+        }
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        deserializeTime_ = duration.count();
+
+        return result;
+    }
+
+    size_t GetMemoryUsage() const
+    {
+        return memoryUsage_;
+    }
+
+    PerformanceMetrics GetPerformanceMetrics() const
+    {
+        PerformanceMetrics metrics;
+        metrics.parseTime = parseTime_;
+        metrics.generateTime = generateTime_;
+        metrics.serializeTime = serializeTime_;
+        metrics.deserializeTime = deserializeTime_;
+        metrics.memoryUsage = memoryUsage_;
+        metrics.fileCount = fileCount_;
+        metrics.lineCount = lineCount_;
+        return metrics;
+    }
+
+    void ResetMetrics()
+    {
+        parseTime_ = 0;
+        generateTime_ = 0;
+        serializeTime_ = 0;
+        deserializeTime_ = 0;
+        memoryUsage_ = 0;
+        fileCount_ = 0;
+        lineCount_ = 0;
+    }
+
+private:
+    double parseTime_ = 0;
+    double generateTime_ = 0;
+    double serializeTime_ = 0;
+    double deserializeTime_ = 0;
+    size_t memoryUsage_ = 0;
+    int32_t fileCount_ = 0;
+    int32_t lineCount_ = 0;
+};
+
+ThriftEngine::ThriftEngine() : impl_(std::make_unique<Impl>()) {}
+ThriftEngine::~ThriftEngine() = default;
+
+ThriftAST ThriftEngine::ParseFiles(const std::vector<std::string> &filePaths)
+{
+    return impl_->ParseFiles(filePaths);
+}
+
+std::vector<uint8_t> ThriftEngine::Serialize(const std::unordered_map<std::string, std::string> &data,
+                                             const SerializationOptions &options)
+{
+    return impl_->Serialize(data, options);
+}
+
+std::unordered_map<std::string, std::string> ThriftEngine::Deserialize(const std::vector<uint8_t> &data,
+                                                                       const SerializationOptions &options)
+{
+    return impl_->Deserialize(data, options);
+}
+
+size_t ThriftEngine::GetMemoryUsage() const
+{
+    return impl_->GetMemoryUsage();
+}
+
+PerformanceMetrics ThriftEngine::GetPerformanceMetrics() const
+{
+    return impl_->GetPerformanceMetrics();
+}
+
+void ThriftEngine::ResetMetrics()
+{
+    impl_->ResetMetrics();
+}
+
+// N-API wrapper functions
+Napi::Value CreateEngine(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    try
+    {
+        auto engine = std::make_unique<ThriftEngine>();
+        return Napi::External<ThriftEngine>::New(env, engine.release());
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value ParseFiles(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsExternal() || !info[1].IsArray())
+    {
+        Napi::TypeError::New(env, "Expected engine and file paths array").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto filePaths = info[1].As<Napi::Array>();
+
+        std::vector<std::string> paths;
+        for (uint32_t i = 0; i < filePaths.Length(); i++)
+        {
+            if (filePaths.Get(i).IsString())
+            {
+                paths.push_back(filePaths.Get(i).As<Napi::String>().Utf8Value());
+            }
+        }
+
+        auto ast = engine->ParseFiles(paths);
+
+        // Convert AST to JavaScript object
+        auto result = Napi::Object::New(env);
+        result.Set("namespaces", Napi::Array::New(env));
+        result.Set("structs", Napi::Array::New(env));
+        result.Set("enums", Napi::Array::New(env));
+        result.Set("services", Napi::Array::New(env));
+        result.Set("includes", Napi::Array::New(env));
+
+        return result;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value Serialize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsExternal() || !info[1].IsObject() || !info[2].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected engine, data object, and options object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto dataObj = info[1].As<Napi::Object>();
+        auto optionsObj = info[2].As<Napi::Object>();
+
+        // Convert JavaScript object to map
+        std::unordered_map<std::string, std::string> data;
+        auto keys = dataObj.GetPropertyNames();
+        for (uint32_t i = 0; i < keys.Length(); i++)
+        {
+            auto key = keys.Get(i).As<Napi::String>().Utf8Value();
+            auto value = dataObj.Get(key).As<Napi::String>().Utf8Value();
+            data[key] = value;
+        }
+
+        // Create serialization options
+        SerializationOptions options;
+        options.protocol = ThriftProtocol::BINARY;
+        options.endianness = Endianness::LITTLE_ENDIAN;
+        options.optimizeForSize = true;
+        options.includeDefaultValues = false;
+        options.validateTypes = true;
+
+        auto result = engine->Serialize(data, options);
+
+        // Convert to Node.js Buffer
+        auto buffer = Napi::Buffer<uint8_t>::Copy(env, result.data(), result.size());
+        return buffer;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value Deserialize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsExternal() || !info[1].IsBuffer() || !info[2].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected engine, buffer, and options object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto buffer = info[1].As<Napi::Buffer<uint8_t>>();
+        auto optionsObj = info[2].As<Napi::Object>();
+
+        // Convert buffer to vector
+        std::vector<uint8_t> data(buffer.Data(), buffer.Data() + buffer.Length());
+
+        // Create serialization options
+        SerializationOptions options;
+        options.protocol = ThriftProtocol::BINARY;
+        options.endianness = Endianness::LITTLE_ENDIAN;
+        options.optimizeForSize = true;
+        options.includeDefaultValues = false;
+        options.validateTypes = true;
+
+        auto result = engine->Deserialize(data, options);
+
+        // Convert map to JavaScript object
+        auto resultObj = Napi::Object::New(env);
+        for (const auto &pair : result)
+        {
+            resultObj.Set(pair.first, pair.second);
+        }
+
+        return resultObj;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value GetPerformanceMetrics(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsExternal())
+    {
+        Napi::TypeError::New(env, "Expected engine").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto metrics = engine->GetPerformanceMetrics();
+
+        auto result = Napi::Object::New(env);
+        result.Set("parseTime", metrics.parseTime);
+        result.Set("generateTime", metrics.generateTime);
+        result.Set("serializeTime", metrics.serializeTime);
+        result.Set("deserializeTime", metrics.deserializeTime);
+        result.Set("memoryUsage", static_cast<double>(metrics.memoryUsage));
+        result.Set("fileCount", metrics.fileCount);
+        result.Set("lineCount", metrics.lineCount);
+
+        return result;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set(Napi::String::New(env, "createEngine"), Napi::Function::New(env, CreateEngine));
+    exports.Set(Napi::String::New(env, "parseFiles"), Napi::Function::New(env, ParseFiles));
+    exports.Set(Napi::String::New(env, "serialize"), Napi::Function::New(env, Serialize));
+    exports.Set(Napi::String::New(env, "deserialize"), Napi::Function::New(env, Deserialize));
+    exports.Set(Napi::String::New(env, "getPerformanceMetrics"), Napi::Function::New(env, GetPerformanceMetrics));
+
+    return exports;
+}
+
+NODE_API_MODULE(thrift_engine_native, Init)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deukpack",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "DeukPack — multi-format IDL pipeline (.deuk native, Protobuf, OpenAPI, JSON Schema, CSV, Thrift). Protobuf-aligned wire; fast C#/C++/JS codegen, CLI. v1: no Excel/table editor workflow",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "build:native": "node-gyp rebuild",
     "build:all": "npm run build && npm run build:cpp && npm run build:cs",
     "build:cpp": "cd native/cpp && mkdir -p build && cd build && cmake .. && make",
-    "build:cs": "cd native/csharp && dotnet build -c Release",
+    "build:cs": "cd DeukPack.Protocol && dotnet build -c Release",
     "test": "jest",
     "benchmark": "node benchmarks/performance.js",
     "dev": "tsc --watch",
@@ -65,6 +65,8 @@
     "bin",
     "scripts/build_deukpack.js",
     "dist",
+    "native/cpp",
+    "binding.gyp",
     "LICENSE",
     "NOTICE",
     "README.md",