lex-neo4j 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ee32c6b5641413d91c9465511f127d1fdbdd5b937f3a35807a42d707cefef58
+  data.tar.gz: e3b9301354201cb3ac20b8da8cb58bf8166951591642bf03d582626739891232
+SHA512:
+  metadata.gz: 278f30ccfc2d078dbc3160032fbda03cdde627a56184e6fc89d9001dc9846dd3b5f46c77e719fc1cf0deeb327ced7fc079af31c853d7f6eae6beac96d1e261d9
+  data.tar.gz: 16b8ab739eb37c008137c8c1a62e740b847f50711ffe80f9aeaf29e51593cb03a183a08b1e3d40c535eac73f244daca4106d2590b8b9cd034ff8f2d59485fc1d

data/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Auto-generated from team-config.yml
+# Team: extensions
+#
+# To apply: scripts/apply-codeowners.sh lex-neo4j
+
+* @LegionIO/maintainers
+* @LegionIO/extensions

data/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"

data/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  excluded-files:
+    uses: LegionIO/.github/.github/workflows/excluded-files.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
+  release:
+    needs: [ci, excluded-files]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rspec_status

@@ -0,0 +1,80 @@
+example_id                                                               | status | run_time        |
+------------------------------------------------------------------------ | ------ | --------------- |
+./spec/legion/extensions/neo4j/client_spec.rb[1:1]                       | passed | 0.00615 seconds |
+./spec/legion/extensions/neo4j/client_spec.rb[1:2]                       | passed | 0.00109 seconds |
+./spec/legion/extensions/neo4j/client_spec.rb[1:3]                       | passed | 0.00054 seconds |
+./spec/legion/extensions/neo4j/client_spec.rb[1:4:1]                     | passed | 0.00014 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:1:1]              | passed | 0.00078 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:2:1]              | passed | 0.00061 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:3:1]              | passed | 0.00062 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:3:2]              | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:4:1]              | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:5:1]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:6:1]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/admin_spec.rb[1:7:1]              | passed | 0.00014 seconds |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:1:1]             | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:1:2]             | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:1:3]             | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:2:1]             | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:2:2:1]           | passed | 0.00055 seconds |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:3:1]             | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/cypher_spec.rb[1:4:1]             | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:1:1] | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:2:1] | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:2:2] | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:3:1] | passed | 0.00009 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:4:1] | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:4:2] | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:4:3] | passed | 0.00009 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:5:1] | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:5:2] | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/graph_data_science_spec.rb[1:6:1] | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:1:1]            | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:2:1]            | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:2:2]            | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:2:3]            | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:3:1]            | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:3:2]            | passed | 0.00008 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:4:1]            | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:5:1]            | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:5:2]            | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:6:1]            | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:6:2]            | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/indexes_spec.rb[1:7:1]            | passed | 0.00009 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:1:1]              | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:1:2]              | passed | 0.00414 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:2:1]              | passed | 0.00015 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:3:1]              | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:3:2]              | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:4:1]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:4:2]              | passed | 0.00009 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:5:1]              | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:5:2]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:5:3]              | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:6:1]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:6:2]              | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:7:1]              | passed | 0.00043 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:7:2]              | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/nodes_spec.rb[1:8:1]              | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:1:1]      | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:2:1]      | passed | 0.0002 seconds  |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:3:1]      | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:3:2]      | passed | 0.00008 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:4:1]      | passed | 0.00008 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:5:1]      | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:5:2]      | passed | 0.0001 seconds  |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:6:1]      | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:6:2]      | passed | 0.00018 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:6:3]      | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:6:4]      | passed | 0.00012 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:7:1]      | passed | 0.00011 seconds |
+./spec/legion/extensions/neo4j/runners/relationships_spec.rb[1:8:1]      | passed | 0.00017 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:1:1]       | passed | 0.00015 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:1:2]       | passed | 0.00013 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:2:1]       | passed | 0.00014 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:2:2:1]     | passed | 0.00014 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:3:1]       | passed | 0.00014 seconds |
+./spec/legion/extensions/neo4j/runners/transactions_spec.rb[1:4:1]       | passed | 0.00019 seconds |
+./spec/legion/extensions/neo4j_spec.rb[1:1]                              | passed | 0.00002 seconds |
+./spec/legion/extensions/neo4j_spec.rb[1:2]                              | passed | 0.00002 seconds |
+./spec/legion/extensions/neo4j_spec.rb[1:3]                              | passed | 0.00002 seconds |

data/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_gem:
+  rubocop-legion: config/lex.yml
+
+Metrics/ParameterLists:
+  Max: 11
+
+Legion/Extension/RunnerReturnHash:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [0.1.0] - 2026-05-28
+
+### Added
+- Initial release
+- Cypher runner (raw query, single result, multi-statement)
+- Nodes runner (find, get, create, update, delete, merge, count, list labels)
+- Relationships runner (find, get, create, update, delete, merge, neighbors, shortest path, list types)
+- Indexes runner (list/create/drop indexes, list/create/drop constraints — uniqueness and existence)
+- Transactions runner (begin, execute, commit, rollback)
+- Admin runner (server info, discovery, databases, procedures, functions, APOC stats)
+- Graph Data Science runner (project/drop graphs, PageRank, Louvain, node similarity)
+- Standalone Client class with read_only guard and configurable database
+- Basic auth (username/password) via Faraday
+- CypherError raised on Neo4j query errors

data/CLAUDE.md

@@ -0,0 +1,33 @@
+# lex-neo4j
+
+Legion Extension connecting LegionIO to Neo4j graph database via the HTTP Cypher transaction API. Provides runners for Cypher queries, nodes, relationships, indexes/constraints, transactions, administration, and Graph Data Science (GDS) algorithms.
+
+## Architecture
+
+```
+Legion::Extensions::Neo4j
+├── Runners/
+│   ├── Cypher            # Raw query execution, single/multi-statement
+│   ├── Nodes             # CRUD + merge, count, labels
+│   ├── Relationships     # CRUD + merge, neighbors, shortest path, types
+│   ├── Indexes           # Indexes and constraints (uniqueness, existence, fulltext)
+│   ├── Transactions      # Explicit transaction lifecycle (begin/execute/commit/rollback)
+│   ├── Admin             # Server info, databases, procedures, functions, APOC stats
+│   └── GraphDataScience  # GDS graph projections, PageRank, Louvain, node similarity
+├── Helpers/Client        # Faraday connection (Basic auth)
+├── Errors                # ReadOnlyError, CypherError
+└── Client                # Standalone client class
+```
+
+## Key Design Decisions
+
+- Uses Neo4j HTTP Cypher Transaction API (`/db/{database}/tx/commit` for auto-commit, `/db/{database}/tx` for explicit transactions)
+- Basic auth with `Authorization: Basic base64(user:pass)` header
+- Default database is `neo4j` (configurable)
+- Default URL is `http://localhost:7474` (configurable)
+- `CypherError` raised when Neo4j returns errors in the response body
+- **Read-Only Guard**: write operations raise `ReadOnlyError` when `read_only: true`
+- Node/relationship IDs use Neo4j 5.x `elementId()` (string format like `4:uuid:offset`)
+- GDS runner assumes the Graph Data Science plugin is installed
+- Admin operations against `system` database where required (e.g., SHOW DATABASES, CREATE DATABASE)
+- Depends on `faraday` (>= 2.0)

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop'
+  gem 'rubocop-legion', '~> 0.1'
+  gem 'simplecov'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LegionIO
+
+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.

data/README.md

@@ -0,0 +1,91 @@
+# lex-neo4j
+
+Legion Extension for [Neo4j](https://neo4j.com/) graph database via the HTTP Cypher transaction API.
+
+## Installation
+
+```ruby
+gem 'lex-neo4j'
+```
+
+## Usage
+
+```ruby
+client = Legion::Extensions::Neo4j::Client.new(
+  url: 'http://localhost:7474',
+  username: 'neo4j',
+  password: 'your-password',
+  database: 'neo4j'
+)
+
+# Raw Cypher
+client.query('MATCH (n:Person) RETURN n LIMIT 10')
+client.query('CREATE (n:Person {name: $name}) RETURN n', parameters: { name: 'Alice' })
+
+# Nodes
+client.find_nodes(label: 'Person', properties: { name: 'Alice' })
+client.create_node(label: 'Person', properties: { name: 'Bob', age: 30 })
+client.merge_node(label: 'Person', match_properties: { email: 'bob@example.com' }, on_create: { created_at: Time.now.to_s })
+client.count_nodes(label: 'Person')
+client.list_labels
+
+# Relationships
+client.create_relationship(from_id: node1_id, to_id: node2_id, type: 'KNOWS', properties: { since: 2020 })
+client.neighbors(id: node_id, direction: :outgoing, type: 'KNOWS')
+client.shortest_path(from_id: node1_id, to_id: node2_id)
+client.list_relationship_types
+
+# Indexes & Constraints
+client.list_indexes
+client.create_index(label: 'Person', properties: ['name', 'email'], name: 'idx_person_name_email')
+client.create_uniqueness_constraint(label: 'Person', property: 'email', name: 'uniq_person_email')
+client.create_existence_constraint(label: 'Person', property: 'name')
+
+# Explicit Transactions
+tx = client.begin_transaction
+client.execute_in_transaction(transaction_url: tx[:location], statements: ['CREATE (n:Temp) RETURN n'])
+client.commit_transaction(transaction_url: tx[:location])
+
+# Administration
+client.server_info
+client.list_databases
+client.list_procedures
+client.call_procedure(name: 'dbms.components')
+
+# Graph Data Science (requires GDS plugin)
+client.project_graph(name: 'social', node_projection: 'Person', relationship_projection: 'KNOWS')
+client.run_pagerank(graph_name: 'social')
+client.run_louvain(graph_name: 'social')
+client.run_node_similarity(graph_name: 'social')
+client.drop_graph(name: 'social')
+```
+
+### Read-Only Mode
+
+```ruby
+client = Legion::Extensions::Neo4j::Client.new(
+  url: 'http://localhost:7474',
+  username: 'neo4j',
+  password: 'pass',
+  read_only: true
+)
+
+client.find_nodes(label: 'Person')  # works
+client.create_node(label: 'Person') # raises ReadOnlyError
+```
+
+## Runners
+
+| Runner | Purpose |
+|--------|---------|
+| Cypher | Raw query execution, multi-statement batches |
+| Nodes | Node CRUD, merge, count, label listing |
+| Relationships | Relationship CRUD, merge, traversal, shortest path |
+| Indexes | Index and constraint management (range, fulltext, uniqueness, existence) |
+| Transactions | Explicit transaction lifecycle |
+| Admin | Server info, database management, procedures, functions |
+| GraphDataScience | GDS graph projections and algorithms (PageRank, Louvain, similarity) |
+
+## License
+
+MIT

data/lex-neo4j.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/neo4j/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-neo4j'
+  spec.version       = Legion::Extensions::Neo4j::VERSION
+  spec.authors       = ['Matthew Iverson']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Neo4j'
+  spec.description   = 'Connects LegionIO to Neo4j graph database via HTTP Cypher transaction API'
+  spec.homepage      = 'https://github.com/LegionIO/lex-neo4j'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = 'https://github.com/LegionIO/lex-neo4j'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-neo4j'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-neo4j'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-neo4j/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday',            '>= 2.0'
+  spec.add_dependency 'legion-cache',       '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',       '>= 1.4.9'
+  spec.add_dependency 'legion-data',        '>= 1.4.17'
+  spec.add_dependency 'legion-json',        '>= 1.2.1'
+  spec.add_dependency 'legion-logging',     '>= 1.3.2'
+  spec.add_dependency 'legion-settings',    '>= 1.3.14'
+  spec.add_dependency 'legion-transport',   '>= 1.3.9'
+end

data/lib/legion/extensions/neo4j/client.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+require 'legion/extensions/neo4j/runners/cypher'
+require 'legion/extensions/neo4j/runners/nodes'
+require 'legion/extensions/neo4j/runners/relationships'
+require 'legion/extensions/neo4j/runners/indexes'
+require 'legion/extensions/neo4j/runners/transactions'
+require 'legion/extensions/neo4j/runners/admin'
+require 'legion/extensions/neo4j/runners/graph_data_science'
+
+module Legion
+  module Extensions
+    module Neo4j
+      class Client
+        include Helpers::Client
+        include Runners::Cypher
+        include Runners::Nodes
+        include Runners::Relationships
+        include Runners::Indexes
+        include Runners::Transactions
+        include Runners::Admin
+        include Runners::GraphDataScience
+
+        attr_reader :opts
+
+        def initialize(url: 'http://localhost:7474', username: 'neo4j', password: nil, database: 'neo4j',
+                       read_only: false, **extra)
+          @opts = { url: url, username: username, password: password, database: database,
+                    read_only: read_only, **extra }
+        end
+
+        def connection(**override)
+          super(**@opts.merge(override.compact))
+        end
+
+        def execute_cypher(query, parameters: {}, database: nil, **override)
+          db = database || @opts[:database]
+          super(query, parameters: parameters, database: db, **@opts.merge(override.compact))
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Neo4j
+      class ReadOnlyError < StandardError; end
+      class CypherError < StandardError; end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/helpers/client.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'base64'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Helpers
+        module Client
+          def connection(url: nil, username: nil, password: nil, _database: 'neo4j', **_opts)
+            Faraday.new(url: url) do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}" if username && password
+              conn.headers['Content-Type'] = 'application/json'
+              conn.headers['Accept'] = 'application/json'
+            end
+          end
+
+          def execute_cypher(query, parameters: {}, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            payload = { statements: [{ statement: query, parameters: parameters }] }
+            resp = connection(url: url, username: username, password: password)
+                   .post("/db/#{database}/tx/commit", payload)
+            body = resp.body
+            raise CypherError, body[:errors].map { |e| e['message'] }.join('; ') if body.is_a?(Hash) && body[:errors] && !body[:errors].empty?
+
+            body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/admin.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Admin
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def server_info(url: nil, username: nil, password: nil, **)
+            resp = connection(url: url, username: username, password: password).get('/')
+            resp.body
+          end
+
+          def discovery(url: nil, username: nil, password: nil, **)
+            resp = connection(url: url, username: username, password: password).get('/db/data/')
+            resp.body
+          end
+
+          def list_databases(url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW DATABASES', parameters: {}, database: 'system',
+                                            url: url, username: username, password: password)
+          end
+
+          def database_info(name: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW DATABASE $name', parameters: { name: name }, database: 'system',
+                                                  url: url, username: username, password: password)
+          end
+
+          def create_database(name:, url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher("CREATE DATABASE #{name}", parameters: {}, database: 'system',
+                                                     url: url, username: username, password: password)
+          end
+
+          def drop_database(name:, url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher("DROP DATABASE #{name} IF EXISTS", parameters: {}, database: 'system',
+                                                             url: url, username: username, password: password)
+          end
+
+          def list_procedures(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW PROCEDURES', parameters: {}, database: database,
+                                             url: url, username: username, password: password)
+          end
+
+          def list_functions(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW FUNCTIONS', parameters: {}, database: database,
+                                            url: url, username: username, password: password)
+          end
+
+          def call_procedure(name:, args: [], database: 'neo4j', url: nil, username: nil, password: nil, **)
+            arg_placeholders = args.each_index.map { |i| "$arg#{i}" }.join(', ')
+            params = args.each_with_index.to_h { |v, i| ["arg#{i}", v] }
+            cypher = "CALL #{name}(#{arg_placeholders})"
+            execute_cypher(cypher, parameters: params, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def db_stats(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher(
+              'CALL apoc.meta.stats() YIELD labels, relTypes, nodeCount, relCount ' \
+              'RETURN labels, relTypes, nodeCount, relCount',
+              parameters: {}, database: database,
+              url: url, username: username, password: password
+            )
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/cypher.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Cypher
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def query(statement, parameters: {}, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher(statement, parameters: parameters, database: database,
+                                     url: url, username: username, password: password)
+          end
+
+          def query_single(statement, parameters: {}, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            result = execute_cypher(statement, parameters: parameters, database: database,
+                                              url: url, username: username, password: password)
+            results = result.dig('results', 0, 'data')
+            return nil if results.nil? || results.empty?
+
+            results.first
+          end
+
+          def multi_statement(statements, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            payload = {
+              statements: statements.map do |s|
+                if s.is_a?(String)
+                  { statement: s, parameters: {} }
+                else
+                  { statement: s[:statement], parameters: s[:parameters] || {} }
+                end
+              end
+            }
+            resp = connection(url: url, username: username, password: password)
+                   .post("/db/#{database}/tx/commit", payload)
+            body = resp.body
+            raise CypherError, body[:errors].map { |e| e['message'] }.join('; ') if body.is_a?(Hash) && body[:errors] && !body[:errors].empty?
+
+            body
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/graph_data_science.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module GraphDataScience
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def list_graphs(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('CALL gds.graph.list() YIELD graphName, nodeCount, relationshipCount ' \
+                           'RETURN graphName, nodeCount, relationshipCount',
+                           parameters: {}, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def project_graph(name:, node_projection:, relationship_projection:, database: 'neo4j',
+                            url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher('CALL gds.graph.project($name, $nodes, $rels)',
+                           parameters: { name: name, nodes: node_projection, rels: relationship_projection },
+                           database: database, url: url, username: username, password: password)
+          end
+
+          def drop_graph(name:, database: 'neo4j', url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher('CALL gds.graph.drop($name)',
+                           parameters: { name: name }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def run_pagerank(graph_name:, write_property: nil, database: 'neo4j', url: nil, username: nil,
+                           password: nil, read_only: false, **)
+            if write_property
+              raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+              execute_cypher('CALL gds.pageRank.write($name, {writeProperty: $prop}) ' \
+                             'YIELD nodePropertiesWritten, ranIterations',
+                             parameters: { name: graph_name, prop: write_property },
+                             database: database, url: url, username: username, password: password)
+            else
+              execute_cypher('CALL gds.pageRank.stream($name) YIELD nodeId, score ' \
+                             'RETURN gds.util.asNode(nodeId).name AS name, score ' \
+                             'ORDER BY score DESC LIMIT 25',
+                             parameters: { name: graph_name },
+                             database: database, url: url, username: username, password: password)
+            end
+          end
+
+          def run_louvain(graph_name:, write_property: nil, database: 'neo4j', url: nil, username: nil,
+                          password: nil, read_only: false, **)
+            if write_property
+              raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+              execute_cypher('CALL gds.louvain.write($name, {writeProperty: $prop}) ' \
+                             'YIELD communityCount, modularity',
+                             parameters: { name: graph_name, prop: write_property },
+                             database: database, url: url, username: username, password: password)
+            else
+              execute_cypher('CALL gds.louvain.stream($name) YIELD nodeId, communityId ' \
+                             'RETURN gds.util.asNode(nodeId).name AS name, communityId ' \
+                             'ORDER BY communityId LIMIT 100',
+                             parameters: { name: graph_name },
+                             database: database, url: url, username: username, password: password)
+            end
+          end
+
+          def run_node_similarity(graph_name:, limit: 25, database: 'neo4j', url: nil, username: nil,
+                                  password: nil, **)
+            execute_cypher('CALL gds.nodeSimilarity.stream($name) YIELD node1, node2, similarity ' \
+                           'RETURN gds.util.asNode(node1).name AS from, ' \
+                           'gds.util.asNode(node2).name AS to, similarity ' \
+                           'ORDER BY similarity DESC LIMIT $limit',
+                           parameters: { name: graph_name, limit: limit },
+                           database: database, url: url, username: username, password: password)
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/indexes.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Indexes
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def list_indexes(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW INDEXES', parameters: {}, database: database,
+                                          url: url, username: username, password: password)
+          end
+
+          def create_index(label:, properties:, name: nil, database: 'neo4j', url: nil, username: nil, password: nil,
+                           read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            props = Array(properties).map { |p| "n.#{p}" }.join(', ')
+            cypher = 'CREATE INDEX'
+            cypher += " #{name}" if name
+            cypher += " FOR (n:#{label}) ON (#{props})"
+            execute_cypher(cypher, parameters: {}, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def create_fulltext_index(name:, labels:, properties:, database: 'neo4j', url: nil, username: nil,
+                                    password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            label_list = Array(labels).map { |l| "'#{l}'" }.join(', ')
+            prop_list = Array(properties).map { |p| "'#{p}'" }.join(', ')
+            cypher = "CREATE FULLTEXT INDEX #{name} FOR (n:#{label_list}) ON EACH [#{prop_list}]"
+            execute_cypher(cypher, parameters: {}, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def drop_index(name:, database: 'neo4j', url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher("DROP INDEX #{name} IF EXISTS", parameters: {}, database: database,
+                                                          url: url, username: username, password: password)
+          end
+
+          def list_constraints(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('SHOW CONSTRAINTS', parameters: {}, database: database,
+                                              url: url, username: username, password: password)
+          end
+
+          def create_uniqueness_constraint(label:, property:, name: nil, database: 'neo4j', url: nil, username: nil,
+                                           password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            cypher = 'CREATE CONSTRAINT'
+            cypher += " #{name}" if name
+            cypher += " FOR (n:#{label}) REQUIRE n.#{property} IS UNIQUE"
+            execute_cypher(cypher, parameters: {}, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def create_existence_constraint(label:, property:, name: nil, database: 'neo4j', url: nil, username: nil,
+                                          password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            cypher = 'CREATE CONSTRAINT'
+            cypher += " #{name}" if name
+            cypher += " FOR (n:#{label}) REQUIRE n.#{property} IS NOT NULL"
+            execute_cypher(cypher, parameters: {}, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def drop_constraint(name:, database: 'neo4j', url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher("DROP CONSTRAINT #{name} IF EXISTS", parameters: {}, database: database,
+                                                               url: url, username: username, password: password)
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/nodes.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Nodes
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def find_nodes(label:, properties: {}, limit: 25, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            where_clause = properties.keys.map { |k| "n.#{k} = $#{k}" }.join(' AND ')
+            cypher = "MATCH (n:#{label})"
+            cypher += " WHERE #{where_clause}" unless where_clause.empty?
+            cypher += ' RETURN n LIMIT $limit'
+            execute_cypher(cypher, parameters: properties.merge(limit: limit),
+                                  database: database, url: url, username: username, password: password)
+          end
+
+          def get_node(id:, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('MATCH (n) WHERE elementId(n) = $id RETURN n',
+                           parameters: { id: id }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def create_node(label:, properties: {}, database: 'neo4j', url: nil, username: nil, password: nil,
+                          read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher("CREATE (n:#{label} $props) RETURN n",
+                           parameters: { props: properties }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def update_node(id:, properties: {}, database: 'neo4j', url: nil, username: nil, password: nil,
+                          read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher('MATCH (n) WHERE elementId(n) = $id SET n += $props RETURN n',
+                           parameters: { id: id, props: properties }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def delete_node(id:, detach: false, database: 'neo4j', url: nil, username: nil, password: nil,
+                          read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            delete_keyword = detach ? 'DETACH DELETE' : 'DELETE'
+            execute_cypher("MATCH (n) WHERE elementId(n) = $id #{delete_keyword} n",
+                           parameters: { id: id }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def merge_node(label:, match_properties: {}, on_create: {}, on_match: {}, database: 'neo4j',
+                         url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            cypher = "MERGE (n:#{label} $match_props)"
+            cypher += ' ON CREATE SET n += $on_create' unless on_create.empty?
+            cypher += ' ON MATCH SET n += $on_match' unless on_match.empty?
+            cypher += ' RETURN n'
+            execute_cypher(cypher,
+                           parameters: { match_props: match_properties, on_create: on_create, on_match: on_match },
+                           database: database, url: url, username: username, password: password)
+          end
+
+          def count_nodes(label: nil, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            cypher = label ? "MATCH (n:#{label}) RETURN count(n) AS count" : 'MATCH (n) RETURN count(n) AS count'
+            execute_cypher(cypher, parameters: {}, database: database,
+                                  url: url, username: username, password: password)
+          end
+
+          def list_labels(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('CALL db.labels() YIELD label RETURN label',
+                           parameters: {}, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/relationships.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Relationships
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def find_relationships(type:, properties: {}, limit: 25, database: 'neo4j',
+                                 url: nil, username: nil, password: nil, **)
+            where_clause = properties.keys.map { |k| "r.#{k} = $#{k}" }.join(' AND ')
+            cypher = "MATCH (a)-[r:#{type}]->(b)"
+            cypher += " WHERE #{where_clause}" unless where_clause.empty?
+            cypher += ' RETURN a, r, b LIMIT $limit'
+            execute_cypher(cypher, parameters: properties.merge(limit: limit),
+                                  database: database, url: url, username: username, password: password)
+          end
+
+          def get_relationship(id:, database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('MATCH (a)-[r]->(b) WHERE elementId(r) = $id RETURN a, r, b',
+                           parameters: { id: id }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def create_relationship(from_id:, to_id:, type:, properties: {}, database: 'neo4j',
+                                  url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            cypher = 'MATCH (a), (b) WHERE elementId(a) = $from_id AND elementId(b) = $to_id ' \
+                     "CREATE (a)-[r:#{type} $props]->(b) RETURN a, r, b"
+            execute_cypher(cypher,
+                           parameters: { from_id: from_id, to_id: to_id, props: properties },
+                           database: database, url: url, username: username, password: password)
+          end
+
+          def update_relationship(id:, properties: {}, database: 'neo4j', url: nil, username: nil, password: nil,
+                                  read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher('MATCH ()-[r]->() WHERE elementId(r) = $id SET r += $props RETURN r',
+                           parameters: { id: id, props: properties }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def delete_relationship(id:, database: 'neo4j', url: nil, username: nil, password: nil,
+                                  read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            execute_cypher('MATCH ()-[r]->() WHERE elementId(r) = $id DELETE r',
+                           parameters: { id: id }, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def merge_relationship(from_id:, to_id:, type:, on_create: {}, on_match: {}, database: 'neo4j',
+                                 url: nil, username: nil, password: nil, read_only: false, **)
+            raise ReadOnlyError, 'Write operations disabled (read_only mode)' if read_only
+
+            cypher = 'MATCH (a), (b) WHERE elementId(a) = $from_id AND elementId(b) = $to_id ' \
+                     "MERGE (a)-[r:#{type}]->(b)"
+            cypher += ' ON CREATE SET r += $on_create' unless on_create.empty?
+            cypher += ' ON MATCH SET r += $on_match' unless on_match.empty?
+            cypher += ' RETURN a, r, b'
+            execute_cypher(cypher,
+                           parameters: { from_id: from_id, to_id: to_id, on_create: on_create, on_match: on_match },
+                           database: database, url: url, username: username, password: password)
+          end
+
+          def list_relationship_types(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            execute_cypher('CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType',
+                           parameters: {}, database: database,
+                           url: url, username: username, password: password)
+          end
+
+          def neighbors(id:, direction: :both, type: nil, limit: 25, database: 'neo4j',
+                        url: nil, username: nil, password: nil, **)
+            rel = type ? ":#{type}" : ''
+            pattern = case direction
+                      when :outgoing then "(a)-[r#{rel}]->(b)"
+                      when :incoming then "(a)<-[r#{rel}]-(b)"
+                      else "(a)-[r#{rel}]-(b)"
+                      end
+            cypher = "MATCH #{pattern} WHERE elementId(a) = $id RETURN b, r LIMIT $limit"
+            execute_cypher(cypher, parameters: { id: id, limit: limit },
+                                  database: database, url: url, username: username, password: password)
+          end
+
+          def shortest_path(from_id:, to_id:, max_depth: 15, database: 'neo4j',
+                            url: nil, username: nil, password: nil, **)
+            cypher = 'MATCH (a), (b) WHERE elementId(a) = $from_id AND elementId(b) = $to_id ' \
+                     "MATCH p = shortestPath((a)-[*..#{max_depth}]-(b)) RETURN p"
+            execute_cypher(cypher, parameters: { from_id: from_id, to_id: to_id },
+                                  database: database, url: url, username: username, password: password)
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/runners/transactions.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/helpers/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      module Runners
+        module Transactions
+          include Legion::Extensions::Neo4j::Helpers::Client
+
+          def begin_transaction(database: 'neo4j', url: nil, username: nil, password: nil, **)
+            resp = connection(url: url, username: username, password: password)
+                   .post("/db/#{database}/tx", { statements: [] })
+            location = resp.headers&.[]('location')
+            { body: resp.body, location: location }
+          end
+
+          def execute_in_transaction(transaction_url:, statements:, url: nil, username: nil, password: nil, **)
+            payload = {
+              statements: statements.map do |s|
+                if s.is_a?(String)
+                  { statement: s, parameters: {} }
+                else
+                  { statement: s[:statement], parameters: s[:parameters] || {} }
+                end
+              end
+            }
+            resp = connection(url: url, username: username, password: password)
+                   .post(transaction_url, payload)
+            body = resp.body
+            raise CypherError, body[:errors].map { |e| e['message'] }.join('; ') if body.is_a?(Hash) && body[:errors] && !body[:errors].empty?
+
+            body
+          end
+
+          def commit_transaction(transaction_url:, url: nil, username: nil, password: nil, **)
+            resp = connection(url: url, username: username, password: password)
+                   .post("#{transaction_url}/commit", { statements: [] })
+            body = resp.body
+            raise CypherError, body[:errors].map { |e| e['message'] }.join('; ') if body.is_a?(Hash) && body[:errors] && !body[:errors].empty?
+
+            body
+          end
+
+          def rollback_transaction(transaction_url:, url: nil, username: nil, password: nil, **)
+            connection(url: url, username: username, password: password).delete(transaction_url)
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/neo4j/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Neo4j
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/neo4j.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/neo4j/version'
+require 'legion/extensions/neo4j/errors'
+require 'legion/extensions/neo4j/helpers/client'
+require 'legion/extensions/neo4j/runners/cypher'
+require 'legion/extensions/neo4j/runners/nodes'
+require 'legion/extensions/neo4j/runners/relationships'
+require 'legion/extensions/neo4j/runners/indexes'
+require 'legion/extensions/neo4j/runners/transactions'
+require 'legion/extensions/neo4j/runners/admin'
+require 'legion/extensions/neo4j/runners/graph_data_science'
+require 'legion/extensions/neo4j/client'
+
+module Legion
+  module Extensions
+    module Neo4j
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
+    end
+  end
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: lex-neo4j
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Iverson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: Connects LegionIO to Neo4j graph database via HTTP Cypher transaction
+  API
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rspec_status"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- LICENSE
+- README.md
+- lex-neo4j.gemspec
+- lib/legion/extensions/neo4j.rb
+- lib/legion/extensions/neo4j/client.rb
+- lib/legion/extensions/neo4j/errors.rb
+- lib/legion/extensions/neo4j/helpers/client.rb
+- lib/legion/extensions/neo4j/runners/admin.rb
+- lib/legion/extensions/neo4j/runners/cypher.rb
+- lib/legion/extensions/neo4j/runners/graph_data_science.rb
+- lib/legion/extensions/neo4j/runners/indexes.rb
+- lib/legion/extensions/neo4j/runners/nodes.rb
+- lib/legion/extensions/neo4j/runners/relationships.rb
+- lib/legion/extensions/neo4j/runners/transactions.rb
+- lib/legion/extensions/neo4j/version.rb
+homepage: https://github.com/LegionIO/lex-neo4j
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-neo4j
+  source_code_uri: https://github.com/LegionIO/lex-neo4j
+  documentation_uri: https://github.com/LegionIO/lex-neo4j
+  changelog_uri: https://github.com/LegionIO/lex-neo4j
+  bug_tracker_uri: https://github.com/LegionIO/lex-neo4j/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Neo4j
+test_files: []