Merge pull request #115 from ds1sqe/rust-core

feat: native Rust ORM for TypeDB with full Python parity

Author: ds1sqe

.github/workflows/release.yml

@@ -45,6 +45,52 @@ jobs:
       - name: Run unit tests
         run: uv run pytest tests/unit/ -v --tb=short
 
+  # Publish Rust crates to crates.io (dependency order)
+  publish-crates:
+    name: Publish Rust crates to crates.io
+    needs: test
+    runs-on: ubuntu-latest
+    environment: release
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Publish type-bridge-core-lib
+        working-directory: type-bridge-core
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -p type-bridge-core-lib
+
+      - name: Wait for crates.io index
+        run: sleep 30
+
+      - name: Publish type-bridge-orm-derive
+        working-directory: type-bridge-core
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -p type-bridge-orm-derive
+
+      - name: Wait for crates.io index
+        run: sleep 30
+
+      - name: Publish type-bridge-orm
+        working-directory: type-bridge-core
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -p type-bridge-orm
+
+      - name: Wait for crates.io index
+        run: sleep 30
+
+      - name: Publish type-bridge-server
+        working-directory: type-bridge-core
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -p type-bridge-server
+
   # Build type-bridge-core wheels for all platforms
   build-core-wheels:
     name: Build core wheel (${{ matrix.target }})
@@ -200,7 +246,7 @@ jobs:
   # Create draft GitHub Release with all artifacts
   github-release:
     name: Create GitHub Release
-    needs: publish-python-pypi
+    needs: [publish-python-pypi, publish-crates]
     runs-on: ubuntu-latest
     permissions:
       contents: write

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "type-bridge"
-version = "1.4.0.dev1"
+version = "1.4.0"
 description = "A modern, Pythonic ORM for TypeDB with an Attribute-based API"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -29,7 +29,7 @@ dependencies = [
     "lark>=1.1.9",
     "jinja2>=3.1.0",
     "typer>=0.15.0",
-    "type-bridge-core>=0.1.0.dev0",
+    "type-bridge-core>=1.4.0",
 ]
 
 [project.urls]

type-bridge-core/Cargo.lock

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "3"
-members = ["crates/core", "crates/python", "crates/server"]
+members = ["crates/core", "crates/python", "crates/server", "crates/orm", "crates/orm-derive"]
 
 [workspace.package]
 license = "MIT"

type-bridge-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "type-bridge-core-lib"
-version = "0.1.0-dev.0"
+version = "1.4.0-rc0"
 edition = "2024"
 description = "TypeQL AST, schema parser, query compiler, and validation engine for type-bridge"
 license.workspace = true

type-bridge-core/crates/core/Cargo.toml

@@ -40,18 +40,27 @@ fn make_match_with_constraints() -> Clause {
     }])
 }
 
-fn make_complex_query() -> Vec<Clause> {
-    let match_clause = Clause::Match(vec![
+fn make_complex_query() -> Clause {
+    Clause::Match(vec![
         Pattern::Entity {
             variable: "$p".to_string(),
             type_name: "person".to_string(),
-            constraints: vec![Constraint::Has {
-                attr_name: "name".to_string(),
-                value: Value::Literal(LiteralValue {
-                    value: json!("Alice"),
-                    value_type: "string".to_string(),
-                }),
-            }],
+            constraints: vec![
+                Constraint::Has {
+                    attr_name: "name".to_string(),
+                    value: Value::Literal(LiteralValue {
+                        value: json!("Alice"),
+                        value_type: "string".to_string(),
+                    }),
+                },
+                Constraint::Has {
+                    attr_name: "age".to_string(),
+                    value: Value::Literal(LiteralValue {
+                        value: json!(30),
+                        value_type: "long".to_string(),
+                    }),
+                },
+            ],
             is_strict: false,
         },
         Pattern::Relation {
@@ -115,49 +124,40 @@ fn make_complex_query() -> Vec<Clause> {
         Pattern::Entity {
             variable: "$d".to_string(),
             type_name: "department".to_string(),
-            constraints: vec![
-                Constraint::Has {
-                    attr_name: "budget".to_string(),
-                    value: Value::Literal(LiteralValue {
-                        value: json!(100000.0),
-                        value_type: "double".to_string(),
-                    }),
-                },
-            ],
+            constraints: vec![Constraint::Has {
+                attr_name: "budget".to_string(),
+                value: Value::Literal(LiteralValue {
+                    value: json!(100000.0),
+                    value_type: "double".to_string(),
+                }),
+            }],
             is_strict: false,
         },
-        Pattern::Iid {
-            variable: "$x".to_string(),
-            iid: "0xabcdef".to_string(),
-        },
-        Pattern::Attribute {
-            variable: "$a".to_string(),
-            type_name: "salary".to_string(),
-            value: Some(Value::Literal(LiteralValue {
-                value: json!(75000),
-                value_type: "long".to_string(),
-            })),
-        },
-    ]);
-
-    let fetch_clause = Clause::Fetch(vec![
-        FetchItem::Attribute {
-            key: "name".to_string(),
-            var: "$p".to_string(),
-            attr_name: "name".to_string(),
-        },
-        FetchItem::Attribute {
-            key: "email".to_string(),
-            var: "$p".to_string(),
-            attr_name: "email".to_string(),
+        Pattern::Entity {
+            variable: "$mgr".to_string(),
+            type_name: "manager".to_string(),
+            constraints: vec![Constraint::Has {
+                attr_name: "level".to_string(),
+                value: Value::Literal(LiteralValue {
+                    value: json!(3),
+                    value_type: "long".to_string(),
+                }),
+            }],
+            is_strict: false,
         },
-        FetchItem::Wildcard {
-            key: "company".to_string(),
-            var: "$c".to_string(),
+        Pattern::Entity {
+            variable: "$proj".to_string(),
+            type_name: "project".to_string(),
+            constraints: vec![Constraint::Has {
+                attr_name: "deadline".to_string(),
+                value: Value::Literal(LiteralValue {
+                    value: json!("2025-12-31"),
+                    value_type: "date".to_string(),
+                }),
+            }],
+            is_strict: false,
         },
-    ]);
-
-    vec![match_clause, fetch_clause]
+    ])
 }
 
 fn make_batch_clauses() -> Vec<Clause> {
@@ -268,10 +268,10 @@ fn bench_compile_match_with_constraints(c: &mut Criterion) {
 
 fn bench_compile_complex_query(c: &mut Criterion) {
     let compiler = QueryCompiler::new();
-    let clauses = make_complex_query();
+    let clause = make_complex_query();
 
     c.bench_function("compile/complex_10_patterns", |b| {
-        b.iter(|| compiler.compile(black_box(&clauses)))
+        b.iter(|| compiler.compile_clause(black_box(&clause)))
     });
 }
 
@@ -305,12 +305,33 @@ fn bench_compile_reduce(c: &mut Criterion) {
                 }),
             },
             ReduceAssignment {
-                variable: "$total".to_string(),
+                variable: "$total_salary".to_string(),
                 expression: Value::FunctionCall(FunctionCallValue {
                     function: "sum".to_string(),
                     args: vec![Value::Variable("$salary".to_string())],
                 }),
             },
+            ReduceAssignment {
+                variable: "$max_age".to_string(),
+                expression: Value::FunctionCall(FunctionCallValue {
+                    function: "max".to_string(),
+                    args: vec![Value::Variable("$age".to_string())],
+                }),
+            },
+            ReduceAssignment {
+                variable: "$min_age".to_string(),
+                expression: Value::FunctionCall(FunctionCallValue {
+                    function: "min".to_string(),
+                    args: vec![Value::Variable("$age".to_string())],
+                }),
+            },
+            ReduceAssignment {
+                variable: "$avg_score".to_string(),
+                expression: Value::FunctionCall(FunctionCallValue {
+                    function: "mean".to_string(),
+                    args: vec![Value::Variable("$score".to_string())],
+                }),
+            },
         ],
         group_by: Some("$dept".to_string()),
     };
@@ -991,6 +1012,18 @@ fn bench_compile_isa_constraint(c: &mut Criterion) {
             ],
             is_strict: false,
         },
+        Pattern::Entity {
+            variable: "$v".to_string(),
+            type_name: "vehicle".to_string(),
+            constraints: vec![
+                Constraint::Isa { type_name: "electric-vehicle".to_string(), strict: false },
+                Constraint::Has {
+                    attr_name: "range".to_string(),
+                    value: Value::Literal(LiteralValue { value: json!(300), value_type: "long".to_string() }),
+                },
+            ],
+            is_strict: false,
+        },
     ]);
     c.bench_function("compile/isa_constraint", |b| {
         b.iter(|| compiler.compile_clause(black_box(&clause)))

type-bridge-core/crates/core/benches/compilation.rs

@@ -38,9 +38,19 @@ fn bench_validate_reserved_word(c: &mut Criterion) {
 
 fn bench_validate_batch_names(c: &mut Criterion) {
     let engine = ValidationEngine::new();
-    let names: Vec<String> = (0..1000)
-        .map(|i| format!("type-name-{}", i))
-        .collect();
+    let mut names: Vec<String> = Vec::with_capacity(1000);
+    for i in 0..400 {
+        names.push(format!("entity-type-{}", i));
+    }
+    for i in 0..300 {
+        names.push(format!("my-long-attribute-name-for-testing-{}", i));
+    }
+    for i in 0..200 {
+        names.push(format!("relation-{}-data", i));
+    }
+    for i in 0..100 {
+        names.push(format!("\u{00e9}l\u{00e8}ve-{}", i));
+    }
 
     c.bench_function("validate_type_name/batch_1000", |b| {
         b.iter(|| {
@@ -240,9 +250,19 @@ fn bench_validate_statement_relation(c: &mut Criterion) {
 
 fn bench_validate_batch_5000(c: &mut Criterion) {
     let engine = ValidationEngine::new();
-    let names: Vec<String> = (0..5000)
-        .map(|i| format!("type-name-{}", i))
-        .collect();
+    let mut names: Vec<String> = Vec::with_capacity(5000);
+    for i in 0..2000 {
+        names.push(format!("entity-type-{}", i));
+    }
+    for i in 0..1500 {
+        names.push(format!("my-long-attribute-name-for-testing-{}", i));
+    }
+    for i in 0..1000 {
+        names.push(format!("relation-{}-data", i));
+    }
+    for i in 0..500 {
+        names.push(format!("\u{00e9}l\u{00e8}ve-{}", i));
+    }
 
     c.bench_function("validate_type_name/batch_5000", |b| {
         b.iter(|| {