lex-cloudflare 0.1.0

data/lib/legion/extensions/cloudflare/ssl/runners/certificate_packs.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Ssl
+        module Runners
+          module CertificatePacks
+            extend Legion::Extensions::Cloudflare::Ssl::Helpers::Client
+
+            def list_packs(zone_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/certificate_packs")
+              { result: response.body, status: response.status }
+            end
+
+            def get_pack(zone_id:, certificate_pack_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/certificate_packs/#{certificate_pack_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def order_pack(zone_id:, body:, **)
+              response = client(**).post("/zones/#{zone_id}/ssl/certificate_packs/order", body)
+              { result: response.body, status: response.status }
+            end
+
+            def update_pack(zone_id:, certificate_pack_id:, body: {}, **)
+              response = client(**).patch("/zones/#{zone_id}/ssl/certificate_packs/#{certificate_pack_id}", body)
+              { result: response.body, status: response.status }
+            end
+
+            def delete_pack(zone_id:, certificate_pack_id:, **)
+              response = client(**).delete("/zones/#{zone_id}/ssl/certificate_packs/#{certificate_pack_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def quota(zone_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/certificate_packs/quota")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/ssl/runners/universal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Ssl
+        module Runners
+          module Universal
+            extend Legion::Extensions::Cloudflare::Ssl::Helpers::Client
+
+            def get_universal_settings(zone_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/universal/settings")
+              { result: response.body, status: response.status }
+            end
+
+            def update_universal_settings(zone_id:, enabled:, **)
+              response = client(**).patch("/zones/#{zone_id}/ssl/universal/settings", { enabled: enabled })
+              { result: response.body, status: response.status }
+            end
+
+            def get_recommendation(zone_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/recommendation")
+              { result: response.body, status: response.status }
+            end
+
+            def list_verification(zone_id:, **)
+              response = client(**).get("/zones/#{zone_id}/ssl/verification")
+              { result: response.body, status: response.status }
+            end
+
+            def update_verification(zone_id:, certificate_pack_id:, validation_method:, **)
+              body = { validation_method: validation_method }
+              response = client(**).patch("/zones/#{zone_id}/ssl/verification/#{certificate_pack_id}", body)
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/ssl.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cloudflare/ssl/helpers/client'
+require 'legion/extensions/cloudflare/ssl/runners/certificate_packs'
+require 'legion/extensions/cloudflare/ssl/runners/universal'
+require 'legion/extensions/cloudflare/ssl/client'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Ssl
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/vectorize/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/indexes'
+require_relative 'runners/vectors'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Vectorize
+        class Client
+          include Helpers::Client
+          include Runners::Indexes
+          include Runners::Vectors
+
+          attr_reader :opts
+
+          def initialize(api_token:, **extra)
+            @opts = { api_token: api_token, **extra }.compact
+          end
+
+          def client(**override)
+            super(**@opts, **override)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/vectorize/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Vectorize
+        module Helpers
+          module Client
+            def client(api_token:, **)
+              Faraday.new(url: 'https://api.cloudflare.com/client/v4') do |conn|
+                conn.request :json
+                conn.response :json, content_type: /\bjson$/
+                conn.headers['Content-Type'] = 'application/json'
+                conn.headers['Authorization'] = "Bearer #{api_token}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/vectorize/runners/indexes.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Vectorize
+        module Runners
+          module Indexes
+            extend Legion::Extensions::Cloudflare::Vectorize::Helpers::Client
+
+            def list_indexes(account_id:, **)
+              response = client(**).get("/accounts/#{account_id}/vectorize/v2/indexes")
+              { result: response.body, status: response.status }
+            end
+
+            def get_index(account_id:, index_name:, **)
+              response = client(**).get("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_index(account_id:, name:, config:, description: nil, **)
+              body = { name: name, config: config, description: description }.compact
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes", body)
+              { result: response.body, status: response.status }
+            end
+
+            def delete_index(account_id:, index_name:, **)
+              response = client(**).delete("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}")
+              { result: response.body, status: response.status }
+            end
+
+            def index_info(account_id:, index_name:, **)
+              response = client(**).get("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/info")
+              { result: response.body, status: response.status }
+            end
+
+            def list_metadata_indexes(account_id:, index_name:, **)
+              response = client(**).get("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/metadata_index/list")
+              { result: response.body, status: response.status }
+            end
+
+            def create_metadata_index(account_id:, index_name:, property_name:, index_type:, **)
+              body = { propertyName: property_name, indexType: index_type }
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/metadata_index/create", body)
+              { result: response.body, status: response.status }
+            end
+
+            def delete_metadata_index(account_id:, index_name:, property_name:, **)
+              body = { propertyName: property_name }
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/metadata_index/delete", body)
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/vectorize/runners/vectors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Vectorize
+        module Runners
+          module Vectors
+            extend Legion::Extensions::Cloudflare::Vectorize::Helpers::Client
+
+            def insert(account_id:, index_name:, body:, **)
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/insert", body)
+              { result: response.body, status: response.status }
+            end
+
+            def upsert(account_id:, index_name:, body:, **)
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/upsert", body)
+              { result: response.body, status: response.status }
+            end
+
+            def query(account_id:, index_name:, vector:, top_k: nil, filter: nil, return_metadata: nil, return_values: nil, **)
+              body = { vector: vector, topK: top_k, filter: filter, returnMetadata: return_metadata, returnValues: return_values }.compact
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/query", body)
+              { result: response.body, status: response.status }
+            end
+
+            def get_by_ids(account_id:, index_name:, ids:, **)
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/get_by_ids", { ids: ids })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_by_ids(account_id:, index_name:, ids:, **)
+              response = client(**).post("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/delete_by_ids", { ids: ids })
+              { result: response.body, status: response.status }
+            end
+
+            def list_vectors(account_id:, index_name:, **)
+              response = client(**).get("/accounts/#{account_id}/vectorize/v2/indexes/#{index_name}/list")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/vectorize.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cloudflare/vectorize/helpers/client'
+require 'legion/extensions/cloudflare/vectorize/runners/indexes'
+require 'legion/extensions/cloudflare/vectorize/runners/vectors'
+require 'legion/extensions/cloudflare/vectorize/client'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module Vectorize
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cloudflare/zero_trust/client.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/devices'
+require_relative 'runners/registrations'
+require_relative 'runners/dex_tests'
+require_relative 'runners/ip_profiles'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        class Client
+          include Helpers::Client
+          include Runners::Devices
+          include Runners::Registrations
+          include Runners::DexTests
+          include Runners::IpProfiles
+
+          attr_reader :opts
+
+          def initialize(api_token:, **extra)
+            @opts = { api_token: api_token, **extra }.compact
+          end
+
+          def client(**override)
+            super(**@opts, **override)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        module Helpers
+          module Client
+            def client(api_token:, **)
+              Faraday.new(url: 'https://api.cloudflare.com/client/v4') do |conn|
+                conn.request :json
+                conn.response :json, content_type: /\bjson$/
+                conn.headers['Content-Type'] = 'application/json'
+                conn.headers['Authorization'] = "Bearer #{api_token}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust/runners/devices.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        module Runners
+          module Devices
+            extend Legion::Extensions::Cloudflare::ZeroTrust::Helpers::Client
+
+            def list_devices(account_id:, per_page: nil, search: nil, **)
+              params = { per_page: per_page, search: search }.compact
+              response = client(**).get("/accounts/#{account_id}/devices/physical-devices", params)
+              { result: response.body, status: response.status }
+            end
+
+            def get_device(account_id:, device_id:, **)
+              response = client(**).get("/accounts/#{account_id}/devices/physical-devices/#{device_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def delete_device(account_id:, device_id:, **)
+              response = client(**).delete("/accounts/#{account_id}/devices/physical-devices/#{device_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def revoke_device(account_id:, device_id:, **)
+              response = client(**).post("/accounts/#{account_id}/devices/physical-devices/#{device_id}/revoke")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust/runners/dex_tests.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        module Runners
+          module DexTests
+            extend Legion::Extensions::Cloudflare::ZeroTrust::Helpers::Client
+
+            def list_dex_tests(account_id:, page: nil, per_page: nil, **)
+              params = { page: page, per_page: per_page }.compact
+              response = client(**).get("/accounts/#{account_id}/dex/devices/dex_tests", params)
+              { result: response.body, status: response.status }
+            end
+
+            def get_dex_test(account_id:, dex_test_id:, **)
+              response = client(**).get("/accounts/#{account_id}/dex/devices/dex_tests/#{dex_test_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_dex_test(account_id:, body:, **)
+              response = client(**).post("/accounts/#{account_id}/dex/devices/dex_tests", body)
+              { result: response.body, status: response.status }
+            end
+
+            def update_dex_test(account_id:, dex_test_id:, body:, **)
+              response = client(**).put("/accounts/#{account_id}/dex/devices/dex_tests/#{dex_test_id}", body)
+              { result: response.body, status: response.status }
+            end
+
+            def delete_dex_test(account_id:, dex_test_id:, **)
+              response = client(**).delete("/accounts/#{account_id}/dex/devices/dex_tests/#{dex_test_id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust/runners/ip_profiles.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        module Runners
+          module IpProfiles
+            extend Legion::Extensions::Cloudflare::ZeroTrust::Helpers::Client
+
+            def list_ip_profiles(account_id:, per_page: nil, **)
+              params = { per_page: per_page }.compact
+              response = client(**).get("/accounts/#{account_id}/devices/ip-profiles", params)
+              { result: response.body, status: response.status }
+            end
+
+            def get_ip_profile(account_id:, profile_id:, **)
+              response = client(**).get("/accounts/#{account_id}/devices/ip-profiles/#{profile_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_ip_profile(account_id:, body:, **)
+              response = client(**).post("/accounts/#{account_id}/devices/ip-profiles", body)
+              { result: response.body, status: response.status }
+            end
+
+            def update_ip_profile(account_id:, profile_id:, body:, **)
+              response = client(**).patch("/accounts/#{account_id}/devices/ip-profiles/#{profile_id}", body)
+              { result: response.body, status: response.status }
+            end
+
+            def delete_ip_profile(account_id:, profile_id:, **)
+              response = client(**).delete("/accounts/#{account_id}/devices/ip-profiles/#{profile_id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust/runners/registrations.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+        module Runners
+          module Registrations
+            extend Legion::Extensions::Cloudflare::ZeroTrust::Helpers::Client
+
+            def list_registrations(account_id:, per_page: nil, search: nil, **)
+              params = { per_page: per_page, search: search }.compact
+              response = client(**).get("/accounts/#{account_id}/devices/registrations", params)
+              { result: response.body, status: response.status }
+            end
+
+            def get_registration(account_id:, registration_id:, **)
+              response = client(**).get("/accounts/#{account_id}/devices/registrations/#{registration_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def delete_registration(account_id:, registration_id:, **)
+              response = client(**).delete("/accounts/#{account_id}/devices/registrations/#{registration_id}")
+              { result: response.body, status: response.status }
+            end
+
+            def revoke_registrations(account_id:, ids:, **)
+              response = client(**).post("/accounts/#{account_id}/devices/registrations/revoke", nil, { id: ids })
+              { result: response.body, status: response.status }
+            end
+
+            def unrevoke_registrations(account_id:, ids:, **)
+              response = client(**).post("/accounts/#{account_id}/devices/registrations/unrevoke", nil, { id: ids })
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare/zero_trust.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cloudflare/zero_trust/helpers/client'
+require 'legion/extensions/cloudflare/zero_trust/runners/devices'
+require 'legion/extensions/cloudflare/zero_trust/runners/registrations'
+require 'legion/extensions/cloudflare/zero_trust/runners/dex_tests'
+require 'legion/extensions/cloudflare/zero_trust/runners/ip_profiles'
+require 'legion/extensions/cloudflare/zero_trust/client'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      module ZeroTrust
+      end
+    end
+  end
+end

data/lib/legion/extensions/cloudflare.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'cloudflare/version'
+require_relative 'cloudflare/dns'
+require_relative 'cloudflare/dns_firewall'
+require_relative 'cloudflare/custom_nameservers'
+require_relative 'cloudflare/zero_trust'
+require_relative 'cloudflare/ssl'
+require_relative 'cloudflare/vectorize'
+require_relative 'cloudflare/ai_gateway'
+require_relative 'cloudflare/ai'
+
+module Legion
+  module Extensions
+    module Cloudflare
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end