datomic-flare 1.0.0

data/components/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Flare
+  module Errors
+    class FlareError < StandardError
+      def initialize(message = nil)
+        super
+      end
+    end
+
+    class RequestError < FlareError
+      attr_reader :request, :payload
+
+      def initialize(message = nil, request: nil, payload: nil)
+        @request = request
+        @payload = payload
+
+        super(message)
+      end
+    end
+  end
+end

data/components/http.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/typhoeus'
+require 'json'
+require_relative '../components/errors'
+
+module Flare
+  module HTTP
+    DEFAULT_ADDRESS = 'http://localhost:3042'
+    ALLOWED_REQUEST_OPTIONS = %i[timeout open_timeout read_timeout write_timeout].freeze
+    DEFAULT_FARADAY_ADAPTER = :typhoeus
+
+    class Client
+      def initialize(config)
+        @address = if config[:credentials][:address].to_s.strip.empty?
+                     DEFAULT_ADDRESS
+                   else
+                     config[:credentials][:address].to_s.sub(
+                       %r{/$}, ''
+                     )
+                   end
+
+        @request_options = config.dig(:options, :connection, :request)&.slice(*ALLOWED_REQUEST_OPTIONS) || {}
+        @faraday_adapter = config.dig(:options, :connection, :adapter) || DEFAULT_FARADAY_ADAPTER
+      end
+
+      def request(path, payload = nil, debug:, request_method: 'POST')
+        url = "#{@address}/#{path}"
+        method = request_method.to_s.strip.downcase.to_sym
+
+        if debug
+          debug_payload = { method: method.to_s.upcase, url: }
+
+          debug_payload[:body] = JSON.parse(payload.to_json) unless payload.nil?
+
+          return debug_payload
+        end
+
+        response = Faraday.new(request: @request_options) do |faraday|
+          faraday.adapter @faraday_adapter
+          faraday.response :raise_error
+        end.send(method) do |req|
+          req.url url
+          req.headers['Content-Type'] = 'application/json'
+          req.body = payload.to_json unless payload.nil?
+        end
+
+        JSON.parse(response.body)
+      rescue Faraday::Error => e
+        raise Errors::RequestError.new("#{e.message}: #{e.response[:body]}", request: e, payload:)
+      end
+    end
+  end
+end

data/controllers/api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Flare
+  class API
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def create_database!(payload, debug: nil)
+      client.request('datomic/create-database', payload, debug:)
+    end
+
+    def delete_database!(payload, debug: nil)
+      client.request(
+        'datomic/delete-database', payload,
+        request_method: 'DELETE', debug:
+      )
+    end
+
+    def transact!(payload, debug: nil)
+      client.request('datomic/transact', payload, debug:)
+    end
+
+    def entity(payload, debug: nil)
+      client.request('datomic/entity', payload, request_method: 'GET', debug:)
+    end
+
+    def datoms(payload, debug: nil)
+      client.request('datomic/datoms', payload, request_method: 'GET', debug:)
+    end
+
+    def get_database_names(debug: nil)
+      client.request(
+        'datomic/get-database-names', request_method: 'GET', debug:
+      )
+    end
+
+    def list_databases(debug: nil)
+      client.request('datomic/list-databases', request_method: 'GET', debug:)
+    end
+
+    def q(payload, debug: nil)
+      client.request('datomic/q', payload, request_method: 'GET', debug:)
+    end
+  end
+end

data/controllers/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../components/http'
+require_relative '../logic/dangerous_override'
+
+require_relative 'dsl'
+require_relative 'api'
+
+module Flare
+  module Controllers
+    class Client
+      attr_reader :dangerously_override
+
+      def initialize(config)
+        @http_client = HTTP::Client.new(config)
+
+        @dangerously_override = (config[:dangerously_override] || {}).freeze
+      end
+
+      def meta(debug: nil)
+        request('meta', request_method: 'GET', debug:)
+      end
+
+      def api
+        @api ||= API.new(self)
+      end
+
+      def dsl
+        @dsl ||= DSL.new(self)
+      end
+
+      def request(path, payload = nil, debug:, request_method: 'POST')
+        @http_client.request(
+          path,
+          DangerousOverrideLogic.apply_dangerous_overrides_to_payload(
+            path, dangerously_override, payload
+          ),
+          request_method:, debug:
+        )
+      end
+    end
+  end
+end

data/controllers/documentation/formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'pp'
+require 'tempfile'
+
+module Flare
+  module Controllers
+    module Documentation
+      module Formatter
+        def self.to_s_and_format(ruby_object)
+          code = PP.pp(ruby_object, String.new)
+
+          format_code(code)
+        end
+
+        def self.format_code(code)
+          Tempfile.create(['code', '.rb']) do |file|
+            file.write(code)
+            file.flush
+
+            options = { autocorrect: true, formatters: [], cache: false }
+
+            config_store = RuboCop::ConfigStore.new
+            config_store.options_config = './docs/templates/.rubocop.yml'
+
+            runner = RuboCop::Runner.new(options, config_store)
+
+            runner.run([file.path])
+
+            File.read(file.path).strip
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/documentation/generator.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require 'liquid'
+require 'babosa'
+
+require 'json'
+
+require_relative 'formatter'
+require_relative '../../ports/dsl/datomic-flare'
+require_relative '../../static/gem'
+
+module Flare
+  module Controllers
+    module Documentation
+      module Generator
+        FLARE_AS_PEER_ADDRESS = ENV.fetch('FLARE_AS_PEER_ADDRESS', nil)
+        FLARE_SOURCE = ENV.fetch('FLARE_SOURCE', nil)
+
+        def self.handler
+          generate_individual_documentations!
+          generate_consolidated_readme!
+          generate_flare_readme!
+        end
+
+        def self.generate_flare_readme!
+          unless File.exist?("#{FLARE_SOURCE}/deps.edn")
+            warn "Couldn't find datomic-flare project at '#{FLARE_SOURCE}/deps.edn'"
+            return
+          end
+
+          template_path = "#{FLARE_SOURCE}/docs/templates/README.md"
+          rendered_path = "#{FLARE_SOURCE}/docs/README.md"
+          readme_path = "#{FLARE_SOURCE}/README.md"
+
+          create_database_and_generate_documentation!(template_path)
+
+          quick_starts = Dir[
+            "#{FLARE_SOURCE}/docs/quick-start/*/README.md"
+          ].map do |path|
+            markdown = File.read(path)
+            source_path = Dir["#{File.dirname(path)}/flare.*"].first
+            language = File.extname(source_path).sub('.', '')
+            source = File.read(source_path)
+
+            "#{markdown}\n\n```#{language}\n#{source.strip}\n```"
+          end
+
+          content_with_quick_starts = Liquid::Template.parse(
+            File.read(rendered_path)
+          ).render(
+            stringify_keys(
+              {
+                quick_starts: quick_starts.join("\n\n")
+              }
+            )
+          )
+
+          content = Liquid::Template.parse(File.read(rendered_path)).render(
+            stringify_keys(
+              {
+                index: generate_index(content_with_quick_starts),
+                quick_starts: quick_starts.join("\n\n")
+              }
+            )
+          )
+
+          puts "> Generating final datomic-flare/README.md: '#{readme_path}'"
+
+          File.write(readme_path, content)
+        end
+
+        def self.generate_consolidated_readme!
+          content = Liquid::Template.parse(File.read('./docs/README.md')).render(
+            stringify_keys(
+              {
+                gem: GEM,
+                dsl: File.read('./docs/dsl.md'),
+                api: File.read('./docs/api.md')
+              }
+            )
+          )
+
+          content = Liquid::Template.parse(File.read('./docs/README.md')).render(
+            stringify_keys(
+              {
+                index: generate_index(content),
+                gem: GEM,
+                dsl: Liquid::Template.parse(
+                  File.read('./docs/dsl.md')
+                ).render(stringify_keys({ gem: GEM })),
+                api: Liquid::Template.parse(
+                  File.read('./docs/api.md')
+                ).render(stringify_keys({ gem: GEM }))
+              }
+            )
+          )
+
+          puts "> Generating final README: './README.md'"
+
+          File.write('./README.md', content)
+        end
+
+        def self.generate_index(content)
+          sections = []
+
+          urls = {}
+
+          content.lines.each do |line|
+            next unless line.strip.start_with?('#')
+
+            base_url = line.strip.split(/#\s+/).last.strip.to_slug.normalize.to_s
+            url = base_url
+
+            url_index = 0
+
+            while urls.key?(url)
+              url_index += 1
+              url = "#{base_url}-#{url_index}"
+            end
+
+            urls[url] = true
+
+            sections << {
+              title: line.strip.split(/#\s+/).last.strip,
+              url:,
+              level: line.strip.split(/\s/).first.strip.size,
+              raw: line
+            }
+          end
+
+          sections.map do |section|
+            if section[:level] <= 1
+              nil
+            else
+              "#{'  ' * (section[:level] - 2)}- [#{section[:title]}](##{section[:url]})"
+            end
+          end.compact.join("\n")
+        end
+
+        def self.generate_individual_documentations!
+          Dir['./docs/templates/*.md'].each do |path|
+            create_database_and_generate_documentation!(path)
+          end
+        end
+
+        def self.create_database_and_generate_documentation!(path)
+          puts "> Connecting to Datomic: '#{FLARE_AS_PEER_ADDRESS}'"
+
+          database_name = "my-datomic-database-docs-#{Flare.uuid.v7}"
+
+          client = Flare.new(
+            credentials: { address: FLARE_AS_PEER_ADDRESS },
+            dangerously_override: { database: { name: database_name } }
+          )
+
+          puts "> Creating database: '#{database_name}'"
+          client.dsl.create_database!(database_name)
+
+          begin
+            state = { database_name: }
+            generate_documentation!(client, state, path)
+          ensure
+            puts "> Destroying database: '#{database_name}'"
+            client.dsl.destroy_database!(database_name)
+          end
+        end
+
+        def self.generate_documentation!(client, state, path)
+          puts "> Generating documentation: #{path}"
+          output = run_and_populate_runnable_codes!(client, state, path)
+          output_path = path.sub('docs/templates/', 'docs/')
+          File.write(output_path, output)
+          puts "> Documentation generated: #{output_path}"
+        end
+
+        def self.run_and_populate_runnable_codes!(client, state, path)
+          output = []
+          buffer = nil
+          next_placeholder = nil
+          File.readlines(path).each do |line|
+            if line.strip.start_with?('```') && !buffer.nil?
+              meta = buffer[:meta].strip.gsub(/`+/, '').split(':')
+              language = meta[0]
+              tag = meta[1] ? meta[1].split('/')[0] : nil
+              action = meta[1] ? meta[1].split('/')[1] : nil
+
+              output << "```#{language}\n" if tag != 'state' && !['to-request', 'render->to-request'].include?(action)
+
+              if %w[bash json].include?(language) &&
+                 tag == 'placeholder' &&
+                 next_placeholder
+                output << if action == 'to-curl'
+                            to_curl(next_placeholder)
+                          elsif action == 'to-json'
+                            to_json(next_placeholder)
+                          else
+                            next_placeholder[:formatted]
+                          end
+
+                next_placeholder = nil if action != 'to-curl'
+              elsif language == 'ruby'
+                source_code = buffer[:lines].join
+
+                if ['render', 'render->to-request'].include?(action)
+                  source_code = Liquid::Template.parse(source_code).render(
+                    stringify_keys({ state: })
+                  )
+                end
+
+                formatted_code = Formatter.format_code(source_code).strip
+
+                if tag == 'state'
+                  execution = execute_code(
+                    client, state,
+                    next_placeholder ? next_placeholder[:result] : nil,
+                    formatted_code
+                  )
+                  state = execution[:state]
+                elsif tag == 'runnable'
+                  output << formatted_code unless ['to-request', 'render->to-request'].include?(action)
+
+                  if ['to-request', 'render->to-request'].include?(action)
+                    execution = execute_code(
+                      client, state.merge({ debug: true }), nil, formatted_code
+                    )
+
+                    state = execution[:state]
+
+                    next_placeholder = {
+                      request: execution[:result]
+                    }
+
+                    execution = execute_code(
+                      client, state.merge({ debug: false }), nil, formatted_code
+                    )
+
+                    state = execution[:state]
+
+                    next_placeholder[:result] = execution[:result]
+                    next_placeholder[:response] = execution[:result]
+                  else
+                    execution = execute_code(client, state, nil, formatted_code)
+
+                    state = execution[:state]
+
+                    next_placeholder = { result: execution[:result] }
+
+                    next_placeholder[:formatted] = Formatter.to_s_and_format(
+                      next_placeholder[:result]
+                    )
+                  end
+                elsif tag == 'placeholder' && next_placeholder
+                  output << next_placeholder[:formatted]
+                  next_placeholder = nil
+                else
+                  output << formatted_code
+                end
+              else
+                output.concat(buffer[:lines])
+              end
+
+              output << "\n```\n" if tag != 'state' && !['to-request', 'render->to-request'].include?(action)
+              buffer = nil
+            elsif line.strip.start_with?('```') && buffer.nil?
+              buffer = { meta: line, lines: [] }
+            elsif !buffer.nil?
+              buffer[:lines] << line
+            else
+              output << line
+            end
+          end
+
+          output.join
+        end
+
+        def self.to_curl(result)
+          http_method = result[:request][:method]
+          url = result[:request][:url]
+          body = result[:request][:body]
+
+          body = body&.except('connection')
+
+          body['database'] = body['database']&.except('name') if body&.key?('database')
+
+          if body&.key?('inputs')
+            body['inputs'] = body['inputs'].map do |input|
+              input['database'] = input['database'].except('name') if input.is_a?(Hash) && input.key?('database')
+              input
+            end
+          end
+
+          curl_command = ''
+
+          if body && (body.key?('data') || body.key?('query'))
+            key = body.key?('data') ? 'data' : 'query'
+
+            <<~BB.strip
+              echo '#{JSON.pretty_generate(body[key])}' | bb -e '(pr-str (edn/read-string (slurp *in*)))'
+            BB
+
+            placeholder = ":CAT#{Flare.uuid.v7}CAT:"
+
+            edn_value = body[key]
+
+            body[key] = placeholder
+
+            curl_command = <<~CURL
+              echo '
+              #{edn_value.strip}
+              ' \\
+              | bb -e '(pr-str (edn/read-string (slurp *in*)))' \\
+              | curl -s #{url} \\
+                -X #{http_method} \\
+                -H "Content-Type: application/json" \\
+                --data-binary @- <<JSON \\
+              | jq
+              #{JSON.pretty_generate(body)}
+              JSON
+            CURL
+
+            curl_command = curl_command.sub("\"#{placeholder}\"", '$(cat)')
+          else
+            json_body = body ? JSON.pretty_generate(body) : nil
+            curl_command = <<~CURL
+              curl -s #{url} \\
+                -X #{http_method} \\
+                -H "Content-Type: application/json" #{json_body ? "\\\n  -d '\n#{json_body}\n'" : ''} \\
+              | jq
+            CURL
+          end
+
+          curl_command.strip
+        end
+
+        def self.to_json(result)
+          data = result[:response].except('meta')
+
+          placeholder_key = ":JSON#{Flare.uuid.v7}JSON:"
+          placeholder_values = []
+
+          if data['data'].is_a?(Hash) && data['data']['tx-data']
+            config = JSON::State.new(
+              indent: ' ',
+              space: ' ',
+              array_nl: '',
+              object_nl: ''
+            )
+            data['data']['tx-data'] = data['data']['tx-data'].each do |array|
+              placeholder_values << JSON.generate(array, config).sub('[ ', '[')
+            end
+            data['data']['tx-data'] = [placeholder_key]
+          end
+
+          output = JSON.pretty_generate(data)
+
+          output.sub(
+            "\"#{placeholder_key}\"",
+            placeholder_values.map.with_index do |value, i|
+              i.zero? ? value : "      #{value}"
+            end.join(",\n")
+          )
+        end
+
+        def self.execute_code(client, state, result, code)
+          context = binding
+          context.local_variable_set(:client, client)
+          context.local_variable_set(:state, state)
+          context.local_variable_set(:result, result)
+          result = context.eval(code)
+          state = context.eval('state')
+          { result:, state: }
+        rescue Exception => e
+          { result: { error: e.message }, state: }
+        end
+
+        def self.stringify_keys(object)
+          result = {}
+
+          object.each do |key, value|
+            string_key = key.to_s
+
+            result[string_key] = value.is_a?(Hash) ? stringify_keys(value) : value
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/controllers/dsl/querying.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../logic/querying'
+
+module Flare
+  module DSLQuerying
+    def find_by_entity_id(id, database: nil, debug: nil)
+      database_input = { latest: true }
+
+      database_input[:name] = database unless database.nil?
+
+      response = client.api.entity(
+        { database: database_input, id: }, debug:
+      )
+
+      return response if debug
+
+      QueryingLogic.entity_to_dsl(response['data'])
+    end
+
+    def query(datalog:, params: nil, database: nil, debug: nil)
+      database_input = { latest: true }
+
+      database_input[:name] = database unless database.nil?
+
+      inputs = [{ database: database_input }]
+
+      unless params.nil?
+        raise "Unexpected params: [#{params.class}] #{params.inspect}" unless params.is_a?(Array)
+
+        inputs.concat(params)
+      end
+
+      response = client.api.q({ inputs:, query: datalog.strip }, debug:)
+
+      debug ? response : response['data']
+    end
+  end
+end

data/controllers/dsl/schema.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../logic/schema'
+require_relative '../../logic/types'
+
+module Flare
+  module DSLSchema
+    def transact_schema!(specification, database: nil, debug: nil)
+      data = SchemaLogic.specification_to_edn(specification)
+
+      payload = { data: }
+
+      payload[:connection] = { database: { name: database } } unless database.nil?
+
+      response = client.api.transact!(payload, debug:)
+
+      debug ? response : true
+    end
+
+    def schema(database: nil, debug: nil)
+      database_input = { latest: true }
+
+      database_input[:name] = database unless database.nil?
+
+      payload = {
+        inputs: [{ database: database_input }],
+        query: SchemaLogic::QUERY
+      }
+
+      response = client.api.q(payload, debug:)
+
+      return response if debug
+
+      SchemaLogic.datoms_to_specification(response['data'])
+    end
+  end
+end