Huge model "associations" and generator refactor

spec/remote_generator/services/command_generator_spec.rb

@@ -2,7 +2,8 @@
   let(:raw_manifest_json) { File.read("spec/fixtures/foobara-manifest.json") }
   let(:raw_manifest) { JSON.parse(raw_manifest_json) }
   let(:command_manifest) { Foobara::Manifest::Command.new(raw_manifest, %i[command GlobalCommand]) }
-  let(:generator) { described_class.new(command_manifest) }
+  let(:generator) { described_class.new(command_manifest, elements_to_generate) }
+  let(:elements_to_generate) { [] }
 
   it "contains base files" do
     expect(generator).to respond_to(:command_name)

spec/remote_generator/services/entity_generator_spec.rb

@@ -3,49 +3,22 @@
   let(:raw_manifest) { JSON.parse(raw_manifest_json) }
   let(:entity_manifest) { Foobara::Manifest::Entity.new(raw_manifest, path) }
   let(:path) { [:type, "SomeOrg::Auth::Referral"] }
-  let(:generator) { generator_class.new(entity_manifest) }
+  let(:generator) { generator_class.new(entity_manifest, elements_to_generate) }
+  let(:elements_to_generate) { [] }
   let(:generator_class) { described_class }
 
   it "has the expected names prefixed as necessary" do
-    expect(generator.atom_name).to eq("ReferralAtom")
-    expect(generator.loaded_name).to eq("LoadedReferral")
-    expect(generator.unloaded_name).to eq("UnloadedReferral")
-    expect(generator.aggregate_name).to eq("ReferralAggregate")
     expect(generator.entity_name).to eq("Referral")
-
-    expect(generator.atom_name(1)).to eq("Auth.ReferralAtom")
-    expect(generator.loaded_name(1)).to eq("Auth.LoadedReferral")
-    expect(generator.unloaded_name(1)).to eq("Auth.UnloadedReferral")
-    expect(generator.aggregate_name(1)).to eq("Auth.ReferralAggregate")
     expect(generator.entity_name(1)).to eq("Auth.Referral")
-
-    expect(generator.atom_name(2)).to eq("SomeOrg.Auth.ReferralAtom")
-    expect(generator.loaded_name(2)).to eq("SomeOrg.Auth.LoadedReferral")
-    expect(generator.unloaded_name(2)).to eq("SomeOrg.Auth.UnloadedReferral")
-    expect(generator.aggregate_name(2)).to eq("SomeOrg.Auth.ReferralAggregate")
     expect(generator.entity_name(2)).to eq("SomeOrg.Auth.Referral")
   end
 
   context "when entity does not have associations" do
     let(:path) { [:type, "SomeOrg::Auth::User"] }
 
     it "has the expected names prefixed as necessary" do
-      expect(generator.atom_name).to eq("LoadedUser")
-      expect(generator.loaded_name).to eq("LoadedUser")
-      expect(generator.unloaded_name).to eq("UnloadedUser")
-      expect(generator.aggregate_name).to eq("UserAggregate")
       expect(generator.entity_name).to eq("User")
-
-      expect(generator.atom_name(1)).to eq("Auth.LoadedUser")
-      expect(generator.loaded_name(1)).to eq("Auth.LoadedUser")
-      expect(generator.unloaded_name(1)).to eq("Auth.UnloadedUser")
-      expect(generator.aggregate_name(1)).to eq("Auth.UserAggregate")
       expect(generator.entity_name(1)).to eq("Auth.User")
-
-      expect(generator.atom_name(2)).to eq("SomeOrg.Auth.LoadedUser")
-      expect(generator.loaded_name(2)).to eq("SomeOrg.Auth.LoadedUser")
-      expect(generator.unloaded_name(2)).to eq("SomeOrg.Auth.UnloadedUser")
-      expect(generator.aggregate_name(2)).to eq("SomeOrg.Auth.UserAggregate")
       expect(generator.entity_name(2)).to eq("SomeOrg.Auth.User")
     end
   end
@@ -70,5 +43,15 @@
         expect(generator.ts_instance_full_name).to eq("SomeOrg.Auth.ReferralAtom")
       end
     end
+
+    context "when it's an aggregate generator" do
+      let(:generator_class) { Foobara::RemoteGenerator::Services::AggregateEntityGenerator }
+
+      it "gives the aggregate path" do
+        expect(generator.ts_instance_path).to eq(["ReferralAggregate"])
+        expect(generator.ts_instance_full_path).to eq(%w[SomeOrg Auth ReferralAggregate])
+        expect(generator.ts_instance_full_name).to eq("SomeOrg.Auth.ReferralAggregate")
+      end
+    end
   end
 end

src/remote_generator/generate_typescript.rb

@@ -76,11 +76,21 @@ def each_element_to_generate
           element_to_generate = elements_to_generate.first
           elements_to_generate.delete(element_to_generate)
 
-          if element_to_generate.is_a?(Services::BaseGenerator)
-            elements_to_generate << element_to_generate.relevant_manifest
+          unless element_to_generate.is_a?(Services::BaseGenerator)
+            RemoteGenerator.generators_for(element_to_generate, elements_to_generate).each do |generator|
+              next unless generator.applicable?
+
+              unless generated.include?(generator)
+                elements_to_generate << generator
+              end
+            end
+
             next
           end
 
+          # TODO: fix this name
+          next unless element_to_generate.applicable?
+
           unless generated.include?(element_to_generate)
             self.element_to_generate = element_to_generate
             yield
@@ -111,13 +121,18 @@ def run_generator
         paths_to_source_code[generator.target_path.join("/")] = generator.generate
       end
 
+      # TODO: eliminate this method
       def each_generator
-        RemoteGenerator.generators_for(element_to_generate, elements_to_generate).each do |generator|
-          next unless generator.applicable?
-
-          self.generator = generator
-          yield
-        end
+        # RemoteGenerator.generators_for(element_to_generate, elements_to_generate).each do |generator|
+        #   next unless generator.applicable?
+        #
+        #   self.generator = generator
+        #   yield
+        # end
+        return unless element_to_generate.applicable?
+
+        self.generator = element_to_generate
+        yield
       end
 
       def manifest

src/remote_generator/services/aggregate_entity_generator.rb

@@ -4,17 +4,29 @@ module Foobara
   module RemoteGenerator
     class Services
       class AggregateEntityGenerator < LoadedEntityGenerator
+        class << self
+          def new(relevant_manifest, elements_to_generate)
+            return super unless self == AggregateEntityGenerator
+
+            if relevant_manifest.has_associations?
+              super
+            else
+              LoadedEntityGenerator.new(relevant_manifest, elements_to_generate)
+            end
+          end
+        end
+
         def target_path
-          [*domain_path, "entities", entity_name, "Aggregate.ts"]
+          [*domain_path, "types", entity_name, "Aggregate.ts"]
         end
 
         def template_path
           ["Entity", "Aggregate.ts.erb"]
         end
 
-        def entity_generators
-          types_depended_on.select(&:entity?).map do |entity|
-            Services::AggregateEntityGenerator.new(entity, elements_to_generate)
+        def model_generators
+          types_depended_on.select(&:model?).map do |model|
+            Services::AggregateModelGenerator.new(model, elements_to_generate)
           end
         end
 

src/remote_generator/services/aggregate_model_generator.rb

@@ -0,0 +1,53 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      class AggregateModelGenerator < ModelGenerator
+        class << self
+          def new(relevant_manifest, elements_to_generate)
+            return super unless self == AggregateModelGenerator
+
+            if relevant_manifest.entity?
+              AggregateEntityGenerator.new(relevant_manifest, elements_to_generate)
+            elsif relevant_manifest.has_associations?
+              super
+            else
+              ModelGenerator.new(relevant_manifest, elements_to_generate)
+            end
+          end
+        end
+
+        def target_path
+          [*domain_path, "types", model_name, "Aggregate.ts"]
+        end
+
+        def template_path
+          ["Model", "Aggregate.ts.erb"]
+        end
+
+        def model_generators
+          types_depended_on.select(&:model?).map do |model|
+            if model.entity?
+              Services::AggregateEntityGenerator.new(model, elements_to_generate)
+            else
+              Services::AggregateModelGenerator.new(model, elements_to_generate)
+            end
+          end
+        end
+
+        def attributes_type_ts_type
+          aggregate_attributes_ts_type
+        end
+
+        def ts_instance_path
+          *prefix, name = scoped_path
+          [*prefix, "#{name}Aggregate"]
+        end
+
+        def ts_instance_full_path
+          *prefix, name = scoped_full_path
+          [*prefix, "#{name}Aggregate"]
+        end
+      end
+    end
+  end
+end

src/remote_generator/services/atom_entity_generator.rb

@@ -2,17 +2,33 @@ module Foobara
   module RemoteGenerator
     class Services
       class AtomEntityGenerator < LoadedEntityGenerator
+        class << self
+          def new(relevant_manifest, elements_to_generate)
+            return super unless self == AtomEntityGenerator
+
+            if relevant_manifest.has_associations?
+              super
+            else
+              LoadedEntityGenerator.new(relevant_manifest, elements_to_generate)
+            end
+          end
+        end
+
         def target_path
-          [*domain_path, "entities", entity_name, "Atom.ts"]
+          [*domain_path, "types", entity_name, "Atom.ts"]
         end
 
         def template_path
           ["Entity", "Atom.ts.erb"]
         end
 
-        def entity_generators
-          types_depended_on.select(&:entity?).map do |entity|
-            Services::UnloadedEntityGenerator.new(entity, elements_to_generate)
+        def model_generators
+          types_depended_on.select(&:model?).map do |model|
+            if model.entity?
+              Services::UnloadedEntityGenerator.new(model, elements_to_generate)
+            else
+              Services::AtomModelGenerator.new(model, elements_to_generate)
+            end
           end
         end
 

src/remote_generator/services/atom_model_generator.rb

@@ -0,0 +1,49 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      class AtomModelGenerator < ModelGenerator
+        class << self
+          def new(relevant_manifest, elements_to_generate)
+            return super unless self == AtomModelGenerator
+
+            if relevant_manifest.entity?
+              AtomEntityGenerator.new(relevant_manifest, elements_to_generate)
+            elsif relevant_manifest.has_associations?
+              super
+            else
+              ModelGenerator.new(relevant_manifest, elements_to_generate)
+            end
+          end
+        end
+
+        def target_path
+          [*domain_path, "types", model_name, "Atom.ts"]
+        end
+
+        def template_path
+          ["Model", "Atom.ts.erb"]
+        end
+
+        def model_generators
+          types_depended_on.select(&:model?).map do |model|
+            if model.entity?
+              Services::UnloadedEntityGenerator.new(model, elements_to_generate)
+            else
+              Services::AtomModelGenerator.new(model, elements_to_generate)
+            end
+          end
+        end
+
+        def ts_instance_path
+          *prefix, name = scoped_path
+          [*prefix, "#{name}Atom"]
+        end
+
+        def ts_instance_full_path
+          *prefix, name = scoped_full_path
+          [*prefix, "#{name}Atom"]
+        end
+      end
+    end
+  end
+end