thundercli 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee0b6c7018e2162267ecfad4743b3974594c4ebd38d489f4f659b354258eb9e6
+  data.tar.gz: fbb9fc8aba354637e6a138fc3e23211491cfecce6bd2e69891702ecbd09a6349
+SHA512:
+  metadata.gz: 287d0ffb7f45c51f4490cb5a1cc0bc4394317f547b97e933fd630b6bc10d0825c58fc8e8fbb0fe3eb40ddc18b395c91794f45b40b65d090f653156c027a03b91
+  data.tar.gz: 9d37e7f243dd8417bcd0c63f1a5ca87262e5c2907ce83a0bf398a567a8c0693fbcbc5d368fdf246466da32ac637b6a89af5e6ba69f67dd63d3bb1641ca52986e

data/README.md

@@ -0,0 +1,5 @@
+# thunder
+
+The application and entry point of every repo. Finds the chunks (`chunks/<name>/`), reads the aggregate config
+(`infra`, `connections`), boots and supervises the chunk processes and provides the CLI. Depends on `thunderchunk`
+and the gems below it.

data/exe/thunder

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thunder'
+
+begin
+  Dry::CLI.new(Thunder::CLI).call(arguments: Thunder::CLI.expand(ARGV))
+rescue Thunder::Error, ThunderChunk::Error => e
+  warn e.message
+  exit 1
+end

data/lib/thunder/application.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Thunder
+  class Application
+    attr_reader :root
+
+    def initialize(root:)
+      @root = Pathname(root)
+
+      load
+    end
+
+    def load
+      @chunks = root.join('chunks').children
+                    .select { |dir| dir.join('config/chunk.rb').file? }
+                    .to_h do |dir|
+        chunk = ThunderChunk::Chunk.new(root_path: dir)
+
+        [chunk.identifier.to_sym, chunk]
+      end
+    end
+
+    def chunks
+      @chunks&.values || []
+    end
+
+    def chunk(identifier)
+      @chunks[identifier.to_sym] || raise(Error, "unknown chunk '#{identifier}'; chunks: #{@chunks.keys.join(', ')}")
+    end
+
+    def inspect
+      "#<#{self.class.name} root=#{root} chunks=#{@chunks&.keys.inspect}>"
+    end
+  end
+end

data/lib/thunder/cli/command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    class Command < Dry::CLI::Command
+      option :env, default: 'development', desc: 'THUNDER_ENV'
+
+      private
+
+      def default_chunk
+        cwd = Pathname(Dir.pwd).expand_path
+        inside = Thunder.application.chunks.find { |chunk| cwd.ascend.include?(chunk.root_path.expand_path) }
+        return inside.identifier if inside
+
+        Thunder.application.chunks.first.identifier if Thunder.application.chunks.one?
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/console.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      class Console < Command
+        desc 'Boot a chunk and open IRB with it; chunk :name switches to another chunk'
+        option :chunk, aliases: ['-c'], desc: 'Chunk name'
+
+        def call(env:, chunk: nil, **)
+          require 'thunder/console'
+          # WARN: AI MADE
+          require 'thunderwire'
+
+          ThunderChunk::SenderDock.resolver = ThunderWire.method(:sender)
+          ThunderChunk::ExternalImporters::Events.resolver = ThunderWire.method(:publisher)
+          # WARN: ---
+
+          Thunder::Console.new(Thunder.application, chunk || default_chunk, env:).start
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/db/create.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Db
+        class Create < Command
+          desc 'Create the database'
+
+          def call(**)
+            Thunder.application.chunks.each do |chunk|
+              chunk.boot
+              chunk.database.create!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/db/drop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Db
+        class Drop < Command
+          desc 'Drop the databases'
+
+          def call(**)
+            Thunder.application.chunks.each do |chunk|
+              chunk.boot
+              chunk.database.drop!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/db/migrate.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Db
+        class Migrate < Command
+          desc 'Migrate the databases'
+
+          def call(**)
+            Thunder.application.chunks.each do |chunk|
+              chunk.boot
+              chunk.database.migrate!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/db/reset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Db
+        class Reset < Command
+          desc 'Reset the databases'
+
+          def call(**)
+            Thunder.application.chunks.each do |chunk|
+              chunk.boot
+              chunk.database.drop!
+              chunk.database.create!
+              chunk.database.migrate!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/db/setup.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Db
+        class Setup < Command
+          desc 'Setups the databases'
+
+          def call(**)
+            Thunder.application.chunks.each do |chunk|
+              chunk.boot
+              chunk.database.create!
+              chunk.database.migrate!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/chunk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        class Chunk < CLI::Command
+          desc 'Create the chunk NAME in chunks/'
+
+          argument :name, required: true, desc: 'Chunk name'
+
+          option :force, type: :boolean, default: false, aliases: ['-f'], desc: 'Overwrites existing files'
+
+          def call(name:, force:, **)
+            Thunder::Generator.new(Thunder.application.root, force:, out:)
+                              .directory('chunk', "chunks/#{name}", chunk_name: name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/command.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        # Base of the generators that write into a chunk: the chunk comes from -c, or from the current directory.
+        # The key of the file (books.add, library/books.added) gives its path and its modules.
+        class Command < CLI::Command
+          option :chunk, aliases: ['-c'], desc: 'Chunk name'
+          option :force, type: :boolean, default: false, aliases: ['-f'], desc: 'Overwrites existing files'
+
+          USE_KINDS = { 'model' => :model, 'operation' => :operation, 'event' => :event,
+                        'external' => :external_operation }.freeze
+
+          private
+
+          # title:String author_id:Integer:optional -> [['title', 'String', false], ['author_id', 'Integer', true]].
+          # The type defaults to String. `optional` instead of a `?`, which the shell would take as a glob.
+          def fields(list)
+            list.map do |field|
+              # The type may hold :: (ActiveRecord::Relation), so only the name and an :optional suffix are split off.
+              name, rest = field.split(':', 2)
+              type = (rest&.delete_suffix(':optional') || 'String').camelize
+              # A model is named in quotes ('Models::Book'): the chunk resolves it on boot (ThunderChunk::TypeNames).
+              type = "'#{type}'" if type.start_with?('Models::')
+              [name, type, rest.to_s.end_with?(':optional')]
+            end
+          end
+
+          # model:book,external:library/books.show -> the use lines. A model is named by its constant (Book); the
+          # others get an accessor from the key (books_add, library_books_show).
+          def uses(list, allowed)
+            list.map do |use|
+              kind, key = use.split(':', 2)
+              unless key && allowed.include?(kind)
+                raise Error, "--use #{use}: expected kind:key with kind in #{allowed.join(', ')}"
+              end
+
+              kind == 'model' ? "use :model, '#{key}'" : "use :#{USE_KINDS[kind]}, '#{key}', as: :#{key.tr('./', '__')}"
+            end
+          end
+
+          # WARN: AI MADE
+          # The class of app/common the chunk's code inherits from, when the chunk has its file (g chunk writes them);
+          # the framework's class otherwise.
+          def parent_for(chunk, common, framework)
+            chunk.root_path.join('app/common').glob("**/#{common.underscore}.rb").any? ? common : framework
+          end
+
+          def chunk_for(name)
+            Thunder.application.chunk(name || default_chunk || raise(Error, 'no chunk given; pass -c CHUNK'))
+          end
+
+          # books.add -> ['books', 'add']; library/books.added -> ['library', 'books', 'added']
+          def segments(key)
+            key.split(%r{[./]})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/event.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        class Event < Command
+          desc 'Create the event KEY (books.added) the chunk publishes'
+
+          argument :key, required: true, desc: 'Event key'
+          argument :fields, type: :array, required: false, desc: 'Payload fields, name:Type (id:Integer title:String)'
+
+          def call(key:, force:, chunk: nil, fields: [], **)
+            chunk = chunk_for(chunk)
+            *modules, name = segments(key).map(&:camelize)
+
+            Thunder::Generator.new(chunk.root_path, force:, out:).template(
+              'event/event.rb.erb', "app/external/messaging/events/#{segments(key).join('/')}.rb",
+              namespace: ["#{chunk.name}::External", 'Messaging', 'Events', *modules], class_name: name,
+              fields: fields(fields)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/model.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        class Model < Command
+          desc 'Create the model NAME and its migration; columns as name:type (title:string author:references)'
+
+          argument :name, required: true, desc: 'Model name'
+          argument :columns, type: :array, required: false, desc: 'Columns, name:type'
+
+          def call(name:, force:, chunk: nil, columns: [], **)
+            chunk = chunk_for(chunk)
+            *modules, class_name = segments(name).map(&:camelize)
+            columns = columns.map { |column| column.split(':', 2) }
+            table_name = segments(name).join('_').pluralize
+            generator = Thunder::Generator.new(chunk.root_path, force:, out:)
+
+            generator.template(
+              'model/model.rb.erb', "app/internal/models/#{segments(name).join('/')}.rb",
+              namespace: ["#{chunk.name}::Internal", 'Models', *modules], class_name:,
+              references: columns.filter_map { |column, type| column if type == 'references' },
+              parent: parent_for(chunk, 'ApplicationModel', 'ThunderChunk::Model')
+            )
+            version = Time.now.utc.strftime('%Y%m%d%H%M%S')
+
+            generator.template(
+              'model/migration.rb.erb', "database/migrate/#{version}_create_#{table_name}.rb",
+              migration_class: "Create#{table_name.camelize}", migration_version: ActiveRecord::Migration.current_version,
+              table_name:, columns:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/operation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        class Operation < Command
+          desc 'Create the operation KEY (books.add); -e makes it external'
+
+          argument :key, required: true, desc: 'Operation key'
+          argument :params, type: :array, required: false,
+                            desc: 'Params, name:Type[:optional] (title:String id:Integer:optional)'
+
+          option :external, type: :boolean, default: false, aliases: ['-e'], desc: 'External operation'
+          option :use, type: :array, default: [],
+                       desc: 'Dependencies, kind:key comma-separated (model:book,operation:books.find,' \
+                             'event:books.added,external:library/books.show)'
+          option :returns, type: :array, default: [],
+                           desc: 'Fields of the returned Hash, name:Type comma-separated (id:Integer,title)'
+
+          def call(key:, force:, external:, chunk: nil, params: [], use: [], returns: [], **)
+            chunk = chunk_for(chunk)
+            *modules, name = segments(key).map(&:camelize)
+            scope = external ? 'external' : 'internal'
+            allowed = external ? %w[operation external] : %w[model operation event external]
+
+            Thunder::Generator.new(chunk.root_path, force:, out:).template(
+              "operation/#{scope}.rb.erb", "app/#{scope}/operations/#{segments(key).join('/')}.rb",
+              namespace: ["#{chunk.name}::#{scope.camelize}", 'Operations', *modules], class_name: name,
+              params: fields(params), uses: uses(use, allowed), returns: fields(returns),
+              parent: parent_for(chunk, "#{scope.camelize}Operation", "ThunderChunk::Operations::#{scope.camelize}")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/outbox.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        # The migration of the table the outbox publisher writes the chunk's events to. One per chunk: a second run
+        # finds the first migration and stops, or rewrites it with --force.
+        class Outbox < Command
+          desc 'Create the migration of the outbox table, where the chunk writes the events it publishes'
+
+          option :table, default: 'thunder_outbox', desc: 'Table name (messaging.outbox.table_name)'
+
+          def call(force:, table:, chunk: nil, **)
+            chunk = chunk_for(chunk)
+            existing = chunk.root_path.glob("database/migrate/*_create_#{table}.rb").first
+            raise Error, "#{existing.relative_path_from(chunk.root_path)} already exists (--force overwrites)" if existing && !force
+
+            path = existing&.relative_path_from(chunk.root_path) ||
+                   "database/migrate/#{Time.now.utc.strftime('%Y%m%d%H%M%S')}_create_#{table}.rb"
+
+            Thunder::Generator.new(chunk.root_path, force:, out:).template(
+              'outbox/migration.rb.erb', path.to_s,
+              migration_class: "Create#{table.camelize}", migration_version: ActiveRecord::Migration.current_version,
+              table_name: table
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/generate/subscriber.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Generate
+        class Subscriber < Command
+          desc 'Create the subscriber of the event KEY of another chunk (library/books.added)'
+
+          argument :routing_key, required: true, desc: 'Routing key, <chunk>/<event>'
+          argument :params, type: :array, required: false, desc: 'Params, name:Type (id:Integer title:String)'
+
+          option :use, type: :array, default: [],
+                       desc: 'Internal operations it calls, kind:key comma-separated (operation:reviews.create)'
+
+          def call(routing_key:, force:, chunk: nil, params: [], use: [], **)
+            chunk = chunk_for(chunk)
+            *modules, name = segments(routing_key).map(&:camelize)
+
+            path = "app/external/messaging/subscribers/#{segments(routing_key).join('/')}.rb"
+
+            Thunder::Generator.new(chunk.root_path, force:, out:).template(
+              'subscriber/subscriber.rb.erb', path,
+              namespace: ["#{chunk.name}::External", 'Messaging', 'Subscribers', *modules], class_name: name,
+              params: fields(params), uses: uses(use, %w[operation])
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/messaging/consumer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      module Messaging
+        class Consumer < Command
+          desc 'Consumes the events the chunk subscribes to'
+
+          argument :chunk_name, required: true, desc: 'Chunk name'
+          argument :broker_name, required: true
+          argument :handler_name, required: true
+
+          def call(chunk_name:, broker_name:, handler_name:, **)
+            require 'thunderwire'
+            require 'thunderchunk/exporters/events'
+
+            # WARN: AI MADE
+            ThunderChunk::SenderDock.resolver = ThunderWire.method(:sender)
+            ThunderChunk::ExternalImporters::Events.resolver = ThunderWire.method(:publisher)
+            # WARN: ---
+
+            chunk = Thunder.application.chunk(chunk_name)
+            chunk.boot(boot: { exporters: [ThunderChunk::Exporters::Events] })
+
+            broker_module = ThunderWire::MessageBroker.get!(broker_name)
+
+            exporter = chunk.exporter.get(:event)
+            handler = ThunderWire::Handler.get!(broker_module, handler_name).new(exporter)
+
+            consumer = broker_module::Consumer.new(**{
+              url: chunk.config['messaging.broker.url'],
+              queue: "#{chunk.identifier}.events",
+              keys: exporter.items.keys,
+              handler:,
+              exchange: chunk.config['messaging.broker.exchange'],
+              dead_exchange: chunk.config['messaging.broker.dead_exchange'],
+              prefetch: chunk.config['messaging.consumer.prefetch'],
+              concurrency: chunk.config['messaging.consumer.concurrency'],
+              delivery_limit: chunk.config['messaging.consumer.delivery_limit']
+            }.compact)
+
+            %w[TERM INT].each { |signal| Signal.trap(signal) { consumer.stop } }
+
+            consumer.start
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/messaging/outbox.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      module Messaging
+        class Outbox < Command
+          desc 'Starts the outbox relay'
+
+          argument :chunk_name, required: true, desc: 'Chunk name'
+
+          def call(chunk_name:, **)
+            require 'thunderwire'
+
+            chunk = Thunder.application.chunk(chunk_name)
+            chunk.boot
+
+            broker_module = ThunderWire::MessageBroker.get!(chunk.config['messaging.broker.type'])
+
+            outbox = broker_module.const_get('Outbox').new(**{
+              url: chunk.config['messaging.broker.url'],
+              chunk: chunk.identifier,
+              exchange: chunk.config['messaging.broker.exchange'],
+              batch_size: chunk.config['messaging.broker.batch_size'],
+              idle: chunk.config['messaging.broker.idle']
+            }.compact)
+
+            %w[TERM INT].each { |signal| Signal.trap(signal) { outbox.stop } }
+
+            outbox.start
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/new.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  module CLI
+    module Commands
+      # Not a Thunder::CLI::Command: the application does not exist yet.
+      class New < Dry::CLI::Command
+        desc 'Create an application in the folder NAME'
+
+        argument :name, required: true, desc: 'Application name'
+
+        option :dev, type: :boolean, default: false, desc: 'Gemfile points to the repository of the running framework'
+        option :path, desc: 'Gemfile points to the framework repository at PATH'
+        option :skip_bundle, type: :boolean, default: false, desc: 'Does not run bundle install'
+        option :skip_git, type: :boolean, default: false, desc: 'Does not run git init'
+        option :force, type: :boolean, default: false, aliases: ['-f'], desc: 'Overwrites existing files'
+
+        def call(name:, dev:, skip_bundle:, skip_git:, force:, path: nil, **)
+          root = Pathname(name).expand_path
+          framework_path = path ? Pathname(path).expand_path : (Thunder::Generator::FRAMEWORK_ROOT if dev)
+
+          Thunder::Generator.new(root, force:, out:).directory(
+            'new', '.', app_name: root.basename.to_s, framework_path:, ruby_version: RUBY_VERSION
+          )
+
+          unless skip_bundle
+            require 'bundler'
+            # The bundle of the running thunder would leak into the one of the new application.
+            Bundler.with_unbundled_env { system('bundle', 'install', chdir: root.to_s) }
+          end
+
+          unless skip_git
+            system('git', 'init', '--quiet', chdir: root.to_s)
+            system('git', 'add', '--all', chdir: root.to_s)
+            system('git', 'commit', '--quiet', '--message', 'thunder new', chdir: root.to_s)
+          end
+
+          out.puts "\ncd #{name} && thunder generate chunk NAME"
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/serve.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      class Serve < Command
+        desc 'Start Http Server'
+
+        argument :chunk_name, required: true, desc: 'Chunk name'
+        argument :protocol_name, required: true
+        argument :wire_name, required: true
+
+        option :ip, default: '0.0.0.0'
+        option :port, default: 3000
+
+        def call(chunk_name:, protocol_name:, wire_name:, ip:, port:, **)
+          require 'thunderwire'
+
+          # WARN: AI MADE
+          ThunderChunk::SenderDock.resolver = ThunderWire.method(:sender)
+          ThunderChunk::ExternalImporters::Events.resolver = ThunderWire.method(:publisher)
+          # WARN: ---
+
+          chunk = Thunder.application.chunk(chunk_name)
+          protocol = ThunderWire::Protocol.get!(protocol_name)
+          wire = ThunderWire::Wire.get!(protocol, wire_name)
+          exporter = wire.exporter
+
+          chunk.boot(boot: { exporters: [exporter] })
+
+          server = ThunderWire::Server.build(chunk, protocol, wire, ip, port)
+
+          server.up
+        end
+      end
+    end
+  end
+end