init

Author: taronsarkisyan

.gitignore

@@ -0,0 +1,25 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# IDE's
+**/.atom/
+**/.idea/
+**/nbproject/
+**/.vscode/
+
+# Docker
+# /*.dockerfile
+# /*.yml
+
+# PIP
+build/*
+dist/*
+venv/*
+
+# Misc
+**/__pycache__
+**/.DS_Store
+**/*.egg-info
+**/desktop.ini
+**/*.log*
+**/*.sql
+**/*.db

LICENSE

@@ -0,0 +1,21 @@
+MIT LICENSE
+
+COPYRIGHT (R) 2025 ARNELIFY. AUTHOR: TARON SARKISYAN
+
+PERMISSION IS HEREBY GRANTED, FREE OF CHARGE, TO ANY PERSON OBTAINING A COPY
+OF THIS SOFTWARE AND ASSOCIATED DOCUMENTATION FILES (THE "SOFTWARE"), TO DEAL
+IN THE SOFTWARE WITHOUT RESTRICTION, INCLUDING WITHOUT LIMITATION THE RIGHTS
+TO USE, COPY, MODIFY, MERGE, PUBLISH, DISTRIBUTE, SUBLICENSE, AND/OR SELL
+COPIES OF THE SOFTWARE, AND TO PERMIT PERSONS TO WHOM THE SOFTWARE IS
+FURNISHED TO DO SO, SUBJECT TO THE FOLLOWING CONDITIONS:
+
+THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN ALL
+COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include arnelify_orm/cpp *.cpp *.hpp

Makefile

@@ -0,0 +1,53 @@
+# Boot Makefile
+# See https://www.gnu.org/software/make/manual/make.html for more about make.
+
+# ENGINE
+ENGINE = g++
+ENGINE_FLAGS = -std=c++2b
+
+# PATH
+PATH_BIN = $(CURDIR)/tests/bin/index.bin
+PATH_SRC = $(CURDIR)/tests/index.py
+
+# INC
+INC_CPP = -I $(CURDIR)/src/cpp
+INC_INCLUDE = -L /usr/include
+INC_JSONCPP = -I /usr/include/jsoncpp/json
+INC = ${INC_CPP} ${INC_INCLUDE} ${INC_JSONCPP}
+
+# LINK
+LINK_JSONCPP = -ljsoncpp
+LINK_ZLIB = -lz
+LINK = ${LINK_JSONCPP} ${LINK_ZLIB}
+
+# PYTHON
+PYTHON = venv/bin/python
+PYTHON_FLAGS = -m
+PYPI = venv/bin/pip
+
+# NUITKA
+NUITKA = venv/bin/nuitka
+NUITKA_FLAGS = --standalone --onefile
+
+# SCRIPTS
+install:
+	clear && find . -type d -name '__pycache__' -exec rm -r {} +
+	rm -rf build && rm -rf dist && rm -rf venv
+	python ${PYTHON_FLAGS} venv venv
+	${PYPI} install -r requirements.txt
+
+build:
+	clear && rm -rf build/* && rm -rf dist/*
+	${PYTHON} setup.py sdist bdist_wheel --plat-name=manylinux2014_x86_64
+	${PYTHON} ${PYTHON_FLAGS} index
+
+test:
+	clear && mkdir -p tests/bin && rm -rf tests/bin/*
+	${PYTHON} ${PYTHON_FLAGS} tests.index
+
+test_nuitka:
+	clear && mkdir -p tests/bin && rm -rf tests/bin/*
+	${NUITKA} ${NUITKA_FLAGS} --output-dir=tests/bin ${PATH_SRC} && clear
+	${PATH_BIN}
+
+.PHONY: build test

README.md

@@ -0,0 +1,75 @@
+<img src="https://static.wikia.nocookie.net/arnelify/images/c/c8/Arnelify-logo-2024.png/revision/latest?cb=20240701012515" style="width:336px;" alt="Arnelify Logo" />
+
+![Arnelify ORM for Python](https://img.shields.io/badge/Arnelify%20ORM%20for%20Python-0.6.1-yellow) ![C++](https://img.shields.io/badge/C++-2b-red) ![G++](https://img.shields.io/badge/G++-14.2.0-blue) ![Python](https://img.shields.io/badge/Python-3.11.2-blue) ![Nuitka](https://img.shields.io/badge/Nuitka-2.6.4-blue)
+
+## 🚀 About
+**Arnelify® ORM for Python** - is a minimalistic dynamic library which is an ORM written in C and C++.
+
+## 📋 Minimal Requirements
+> Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.
+* CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
+* OS: Debian 11 / MacOS 15 / Windows 10 with <a href="https://learn.microsoft.com/en-us/windows/wsl/install">WSL2</a>.
+* RAM: 4 GB
+
+## 📦 Installation
+Installing via pip:
+```
+pip install arnelify-orm
+```
+## 🎉 Usage
+Install dependencies:
+```
+make install
+```
+Compile library:
+```
+make build
+```
+Compile & Run test:
+```
+make test_nuitka
+```
+Run test:
+```
+make test
+```
+## 📚 Code Examples
+Configure the C/C++ IntelliSense plugin for VSCode (optional).
+```
+Clang_format_fallback = Google
+```
+
+IncludePath for VSCode (optional):
+```
+"includePath": [
+  "/opt/homebrew/opt/jsoncpp/include/json",
+  "/opt/homebrew/opt/mysql-client/include"
+],
+```
+You can find code examples <a href="https://github.com/arnelify/arnelify-orm-python/blob/main/tests/index.py">here</a>.
+
+## ⚖️ MIT License
+This software is licensed under the <a href="https://github.com/arnelify/arnelify-orm-python/blob/main/LICENSE">MIT License</a>. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.
+
+## 🛠️ Contributing
+Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.
+
+## ⭐ Release Notes
+Version 0.6.1 - Minimalistic dynamic library
+
+We are excited to introduce the Arnelify ORM dynamic library for Python! Please note that this version is raw and still in active development.
+
+Change log:
+
+* Minimalistic dynamic library
+* NodeJS (Bun) addon
+* FFI Support
+
+Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the ORM's capabilities, and we welcome your feedback and suggestions.
+
+## 🔗 Mentioned
+
+* <a href="https://github.com/arnelify/arnelify-pod-cpp">Arnelify POD for C++</a>
+* <a href="https://github.com/arnelify/arnelify-pod-python">Arnelify POD for Python</a>
+* <a href="https://github.com/arnelify/arnelify-pod-node">Arnelify POD for NodeJS</a>
+* <a href="https://github.com/arnelify/arnelify-react-native">Arnelify React Native</a>

arnelify_orm/__init__.py

@@ -0,0 +1 @@
+from .index import ArnelifyORM

arnelify_orm/cpp/addon.cpp

@@ -0,0 +1,152 @@
+#ifndef ARNELIFY_ORM_ADDON_CPP
+#define ARNELIFY_ORM_ADDON_CPP
+
+#include <future>
+#include <iostream>
+#include <thread>
+
+#include "json.h"
+#include "napi.h"
+
+#include "index.cpp"
+
+ArnelifyORM* orm = nullptr;
+
+Napi::Value orm_create(const Napi::CallbackInfo& args) {
+  Napi::Env env = args.Env();
+  if (args.Length() < 1 || !args[0].IsString()) {
+    Napi::TypeError::New(env,
+                         "[Arnelify ORM]: C++ error: Expected optsWrapped.")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  Napi::String optsWrapped = args[0].As<Napi::String>();
+  std::string serialized = optsWrapped.Utf8Value();
+
+  Json::Value json;
+  Json::CharReaderBuilder reader;
+  std::string errors;
+
+  std::istringstream iss(serialized);
+  if (!Json::parseFromStream(reader, iss, &json, &errors)) {
+    std::cout << "[Arnelify ORM]: C++ error: Invalid cOpts." << std::endl;
+    exit(1);
+  }
+
+  const bool hasDriver =
+      json.isMember("ORM_DRIVER") && json["ORM_DRIVER"].isString();
+  if (!hasDriver) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_DRIVER' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  const bool hasHost = json.isMember("ORM_HOST") && json["ORM_HOST"].isString();
+  if (!hasHost) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_HOST' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  const bool hasName = json.isMember("ORM_NAME") && json["ORM_NAME"].isString();
+  if (!hasName) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_NAME' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  const bool hasUser = json.isMember("ORM_USER") && json["ORM_USER"].isString();
+  if (!hasUser) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_USER' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  const bool hasPass = json.isMember("ORM_PASS") && json["ORM_PASS"].isString();
+  if (!hasPass) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_PASS' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  const bool hasPort = json.isMember("ORM_PORT") && json["ORM_PORT"].isInt();
+  if (!hasPort) {
+    std::cout << "[Arnelify ORM]: C++ error: 'ORM_PORT' is missing."
+              << std::endl;
+    exit(1);
+  }
+
+  ArnelifyORMOpts opts(json["ORM_DRIVER"].asString(),
+                       json["ORM_HOST"].asString(), json["ORM_NAME"].asString(),
+                       json["ORM_USER"].asString(), json["ORM_PASS"].asString(),
+                       json["ORM_PORT"].asInt());
+
+  orm = new ArnelifyORM(opts);
+
+  return env.Undefined();
+}
+
+Napi::Value orm_destroy(const Napi::CallbackInfo& args) {
+  Napi::Env env = args.Env();
+
+  delete orm;
+  orm = nullptr;
+  return env.Undefined();
+}
+
+Napi::Value orm_exec(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (!info.Length() || !info[0].IsString()) {
+    Napi::TypeError::New(env, "[Arnelify ORM]: C++ error: query is missing.")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  if (2 > info.Length() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "[Arnelify ORM]: C++ error: bindings is missing.")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const std::string query = info[0].As<Napi::String>();
+  const std::string serialized = info[1].As<Napi::String>();
+  std::vector<std::string> bindings;
+
+  Json::Value deserialized;
+  Json::CharReaderBuilder reader;
+  std::string errors;
+
+  std::istringstream iss(serialized);
+  if (!Json::parseFromStream(reader, iss, &deserialized, &errors)) {
+    std::cout << "[Arnelify ORM]: C++ error: bindings must be a valid JSON."
+              << std::endl;
+    exit(1);
+  }
+
+  for (int i = 0; deserialized.size() > i; ++i) {
+    const Json::Value& value = deserialized[i];
+    bindings.emplace_back(value.asString());
+  }
+
+  ArnelifyORMRes res = orm->exec(query, bindings);
+  Json::Value json = orm->toJson(res);
+
+  Json::StreamWriterBuilder writer;
+  writer["indentation"] = "";
+  writer["emitUTF8"] = true;
+
+  const std::string out = Json::writeString(writer, json);
+  return Napi::String::New(env, out);
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set("orm_create", Napi::Function::New(env, orm_create));
+  exports.Set("orm_destroy", Napi::Function::New(env, orm_destroy));
+  exports.Set("orm_exec", Napi::Function::New(env, orm_exec));
+  return exports;
+}
+
+NODE_API_MODULE(ARNELIFY_ORM, Init)
+
+#endif

arnelify_orm/cpp/contracts/opts.hpp

@@ -0,0 +1,25 @@
+#ifndef ARNELIFY_ORM_OPTS_HPP
+#define ARNELIFY_ORM_OPTS_HPP
+
+#include <iostream>
+
+struct ArnelifyORMOpts final {
+  const std::string ORM_DRIVER;
+  const std::string ORM_HOST;
+  const std::string ORM_NAME;
+  const std::string ORM_USER;
+  const std::string ORM_PASS;
+  const int ORM_PORT;
+
+  ArnelifyORMOpts(const std::string d, const std::string h,
+                  const std::string n, const std::string u,
+                  const std::string pwd, const int p)
+      : ORM_DRIVER(d),
+        ORM_HOST(h),
+        ORM_NAME(n),
+        ORM_USER(u),
+        ORM_PASS(pwd),
+        ORM_PORT(p) {};
+};
+
+#endif

arnelify_orm/cpp/contracts/res.hpp

@@ -0,0 +1,11 @@
+#ifndef ARNELIFY_ORM_RES_HPP
+#define ARNELIFY_ORM_RES_HPP
+
+#include <iostream>
+#include <map>
+#include <variant>
+
+using ArnelifyORMRow = std::map<std::string, std::variant<std::nullptr_t, std::string>>;
+using ArnelifyORMRes = std::vector<ArnelifyORMRow>;
+
+#endif