foobara-typescript-remote-command-generator 0.0.1

data/src/remote_generator/services/command_errors_index_generator.rb

@@ -0,0 +1,31 @@
+require_relative "command_errors_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class CommandErrorsIndexGenerator < CommandErrorsGenerator
+        alias command_manifest relevant_manifest
+
+        def target_path
+          [*super[0..-2], "errors", "index.ts"]
+        end
+
+        def template_path
+          "Command/errors/index.ts.erb"
+        end
+
+        def dependencies
+          []
+        end
+
+        def applicable?
+          errors_in_this_namespace.any?
+        end
+
+        def import_destructure
+          "* as #{scoped_name}Errors"
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/command_generator.rb

@@ -0,0 +1,41 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class CommandGenerator < TypescriptFromManifestBaseGenerator
+        alias command_manifest relevant_manifest
+
+        def target_path
+          [*scoped_full_path, "index.ts"]
+        end
+
+        def template_path
+          "Command.ts.erb"
+        end
+
+        def domain_generator
+          @domain_generator ||= Services::DomainGenerator.new(domain)
+        end
+
+        foobara_delegate :organization_generator, :domain_name, :organization_name, to: :domain_generator
+
+        def errors_in_this_namespace
+          @errors_in_this_namespace ||= possible_errors.values.map(&:error).uniq.sort_by(&:error_name).select do |error|
+            error.parent&.path&.map(&:to_s) == path.map(&:to_s)
+          end.map do |error_manifest|
+            Services::ErrorGenerator.new(error_manifest)
+          end
+        end
+
+        def dependencies
+          errors_in_this_namespace
+        end
+
+        def command_errors_index_generator
+          Services::CommandErrorsIndexGenerator.new(command_manifest)
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/command_inputs_generator.rb

@@ -0,0 +1,33 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class CommandInputsGenerator < TypescriptFromManifestBaseGenerator
+        alias command_manifest relevant_manifest
+
+        def target_path
+          [*scoped_full_path, "Inputs.ts"]
+        end
+
+        def template_path
+          "Command/Inputs.ts.erb"
+        end
+
+        def model_generators
+          @model_generators ||= inputs_types_depended_on.select(&:model?).uniq.map do |model|
+            if model.entity?
+              Services::EntityGenerator.new(model)
+            else
+              Services::ModelGenerator.new(model)
+            end
+          end
+        end
+
+        def dependencies
+          model_generators
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/command_manifest_generator.rb

@@ -0,0 +1,13 @@
+require_relative "manifest_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class CommandManifestGenerator < ManifestGenerator
+        def target_path
+          [*scoped_full_path, "manifest.json"]
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/command_result_generator.rb

@@ -0,0 +1,80 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class CommandResultGenerator < TypescriptFromManifestBaseGenerator
+        alias command_manifest relevant_manifest
+
+        def result_type
+          command_manifest.result_type
+        end
+
+        def target_path
+          [*scoped_full_path, "Result.ts"]
+        end
+
+        def template_path
+          "Command/Result.ts.erb"
+        end
+
+        def model_generators(type = result_type, initial = true)
+          if type.entity?
+            generator_class = if atom?
+                                if initial
+                                  AtomEntityGenerator
+                                else
+                                  UnloadedEntityGenerator
+                                end
+                              elsif aggregate?
+                                AggregateEntityGenerator
+                              else
+                                EntityGenerator
+                              end
+
+            [generator_class.new(type.to_entity)]
+          elsif type.model?
+            generator_class = if atom?
+                                AtomModelGenerator
+                              elsif aggregate?
+                                AggregateModelGenerator
+                              else
+                                ModelGenerator
+                              end
+
+            [generator_class.new(type.to_model)]
+          elsif type.type.to_sym == :attributes
+            type.attribute_declarations.values.map do |attribute_declaration|
+              model_generators(attribute_declaration, false)
+            end.flatten.uniq
+          else
+            # TODO: handle tuples, associative arrays, arrays
+            []
+          end
+        end
+
+        def atom?
+          serializers&.any? { |s| s == "Foobara::CommandConnectors::Serializers::AtomicSerializer" }
+        end
+
+        def aggregate?
+          serializers&.any? { |s| s == "Foobara::CommandConnectors::Serializers::AggregateSerializer" }
+        end
+
+        def association_depth
+          if atom?
+            AssociationDepth::ATOM
+          elsif aggregate?
+            AssociationDepth::AGGREGATE
+          else
+            AssociationDepth::AMBIGUOUS
+          end
+        end
+
+        def dependencies
+          model_generators
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/dependency_group.rb

@@ -0,0 +1,137 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      class DependencyGroup
+        class CollisionData
+          attr_accessor :points
+
+          def collisions_for_points
+            @collisions_for_points ||= {}
+          end
+        end
+
+        attr_accessor :dependencies, :name
+
+        def initialize(dependencies, name:)
+          self.name = name
+          self.dependencies = dependencies.to_set
+
+          dependencies.each do |dep|
+            if dep.belongs_to_dependency_group
+              # :nocov:
+              raise "Dependency group #{dep} already belongs to dependency group #{dep.dependency_group}"
+              # :nocov:
+            end
+
+            dep.belongs_to_dependency_group = self
+          end
+
+          find_collisions
+        end
+
+        def collision_data_for(dep)
+          key = to_key(dep)
+
+          collision_data[key].tap do |cd|
+            unless cd
+              # :nocov:
+              raise "Dependency #{dep} is not part of this dependency group"
+              # :nocov:
+            end
+          end
+        end
+
+        def set_collision_data_for(dep, collision_data)
+          key = to_key(dep)
+          self.collision_data[key] = collision_data
+        end
+
+        def to_key(dep)
+          [dep.scoped_category, *dep.ts_instance_full_path].map(&:to_s)
+        end
+
+        def collision_data
+          @collision_data ||= {}
+        end
+
+        def non_colliding_dependency_roots
+          roots = Set.new
+
+          dependencies.each do |dep|
+            roots << non_colliding_root(dep)
+          end
+
+          roots
+        end
+
+        def non_colliding_root(dep)
+          root = dep
+          points = points_for(dep)
+          points_climbed = 0
+
+          until points_climbed >= points
+            # TODO: can't use scoped_path because sometimes we want UnloadedUser instead of User. How to fix??
+            points_climbed += dep.scoped_path.size
+            root = root.parent
+          end
+
+          root
+        end
+
+        def points_for(dep)
+          points = collision_data_for(dep).points
+
+          unless points
+            # :nocov:
+            raise "Dependency #{dep} has no collision data"
+            # :nocov:
+          end
+
+          points
+        end
+
+        def non_colliding_type_name(dep, points = points_for(dep))
+          non_colliding_type_path(dep, points).join(".")
+        end
+
+        def non_colliding_type(dep, points = points_for(dep))
+          non_colliding_type_name(dep, points)
+        end
+
+        def non_colliding_type_path(dep, points = points_for(dep))
+          start_at = dep.ts_type_full_path.size - points - 1
+          path = dep.ts_type_full_path[start_at..] || []
+
+          path.map(&:to_s)
+        end
+
+        private
+
+        def find_collisions
+          dependencies.each do |dep|
+            collision_data = CollisionData.new
+
+            points = 0
+
+            loop do
+              name = non_colliding_type_name(dep, points)
+
+              collisions = dependencies.select do |other_dep|
+                dep != other_dep && name == non_colliding_type_name(other_dep, points)
+              end
+
+              if collisions.empty?
+                collision_data.points = points
+                set_collision_data_for(dep, collision_data)
+                break
+              else
+                collision_data.collisions_for_points[points] = collisions
+                points += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/domain_config_generator.rb

@@ -0,0 +1,21 @@
+require_relative "domain_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class DomainConfigGenerator < DomainGenerator
+        def target_path
+          [*super[0..-2], "config.ts"]
+        end
+
+        def template_path
+          "Domain/config.ts.erb"
+        end
+
+        def dependencies
+          []
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/domain_generator.rb

@@ -0,0 +1,63 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class DomainGenerator < TypescriptFromManifestBaseGenerator
+        alias domain_manifest relevant_manifest
+
+        def import_destructure
+          "* as #{domain_name}"
+        end
+
+        def target_path
+          if global?
+            ["GlobalDomain", "index.ts"]
+          else
+            [*scoped_full_path, "index.ts"]
+          end
+        end
+
+        def template_path
+          "Domain.ts.erb"
+        end
+
+        def command_generators
+          @command_generators ||= domain_manifest.commands.map do |command_manifest|
+            CommandGenerator.new(command_manifest)
+          end
+        end
+
+        def entity_generators
+          @entity_generators ||= domain_manifest.entities.map do |entity_manifest|
+            EntityGenerator.new(entity_manifest)
+          end
+        end
+
+        def model_generators
+          @model_generators ||= begin
+            only_models = domain_manifest.models.reject(&:entity?)
+
+            only_models.map do |model_manifest|
+              ModelGenerator.new(model_manifest)
+            end
+          end
+        end
+
+        def dependencies
+          [*command_generators, *model_generators, *entity_generators, *organization]
+        end
+
+        def domain_name
+          scoped_short_name || "GlobalDomain"
+        end
+
+        def organization_generator
+          @organization_generator ||= OrganizationGenerator.new(domain_manifest.organization)
+        end
+
+        foobara_delegate :organization_name, to: :organization_generator
+      end
+    end
+  end
+end

data/src/remote_generator/services/domain_manifest_generator.rb

@@ -0,0 +1,17 @@
+require_relative "manifest_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class DomainManifestGenerator < ManifestGenerator
+        def target_path
+          if global?
+            ["GlobalDomain", "manifest.json"]
+          else
+            [*scoped_full_path, "manifest.json"]
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/entity_generator.rb

@@ -0,0 +1,43 @@
+require_relative "model_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class EntityGenerator < ModelGenerator
+        alias entity_manifest relevant_manifest
+
+        def target_path
+          [*domain.scoped_full_path, "types", entity_name, "Ambiguous.ts"]
+        end
+
+        def template_path
+          ["Entity", "Ambiguous.ts.erb"]
+        end
+
+        def entity_name(...)
+          model_name(...)
+        end
+
+        def primary_key_name
+          primary_key_attribute
+        end
+
+        def primary_key_ts_type
+          foobara_type_to_ts_type(primary_key_type, dependency_group:)
+        end
+
+        def entity_name_downcase
+          model_name_downcase
+        end
+
+        def attribute_names
+          super - [primary_key_name]
+        end
+
+        def association_property_paths_ts
+          associations.keys.map { |k| DataPath.parse(k).path.map(&:to_s) }.inspect
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/entity_manifest_generator.rb

@@ -0,0 +1,10 @@
+require_relative "model_manifest_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class EntityManifestGenerator < ModelManifestGenerator
+      end
+    end
+  end
+end

data/src/remote_generator/services/entity_variants_generator.rb

@@ -0,0 +1,47 @@
+require_relative "model_variants_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class EntityVariantsGenerator < EntityGenerator
+        def target_path
+          [*domain.scoped_full_path, "types", "#{model_name}.ts"]
+        end
+
+        def template_path
+          "EntityVariants.ts.erb"
+        end
+
+        def entity_generator
+          EntityGenerator.new(entity_manifest)
+        end
+
+        def unloaded_entity_generator
+          UnloadedEntityGenerator.new(entity_manifest)
+        end
+
+        def loaded_entity_generator
+          LoadedEntityGenerator.new(entity_manifest)
+        end
+
+        def atom_entity_generator
+          AtomEntityGenerator.new(entity_manifest)
+        end
+
+        def aggregate_entity_generator
+          AggregateEntityGenerator.new(entity_manifest)
+        end
+
+        def dependencies
+          Set[
+           entity_generator,
+           unloaded_entity_generator,
+           loaded_entity_generator,
+           atom_entity_generator,
+           aggregate_entity_generator
+         ]
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/error_generator.rb

@@ -0,0 +1,68 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ErrorGenerator < TypescriptFromManifestBaseGenerator
+        alias error_manifest relevant_manifest
+
+        def target_path
+          p = parent
+
+          basename = "#{error_name}.ts"
+
+          case parent
+          when OrganizationGenerator, DomainGenerator, CommandGenerator
+            [*p.target_dir, "errors", basename]
+          when nil
+            # :nocov:
+            raise "Expected #{error_name} to have a parent but it did not"
+            # :nocov:
+          else
+            [*p.target_dir, basename]
+          end
+        end
+
+        def error_base_class
+          case category
+          when "data"
+            "DataError"
+          else
+            "RuntimeError"
+          end
+        end
+
+        def template_path
+          "Error.ts.erb"
+        end
+
+        def context_type_declaration
+          @context_type_declaration ||= Manifest::TypeDeclaration.new(root_manifest, [*path, :context_type_declaration])
+        end
+
+        def context_ts_type
+          if context_type_declaration.is_a?(Manifest::Attributes) && context_type_declaration.empty?
+            # TODO: update other parts of the generator that disable the linting rule to use this instead...
+            "Record<string, never>"
+          else
+            foobara_type_to_ts_type(context_type_declaration, dependency_group:)
+          end
+        end
+
+        def dependencies
+          types_depended_on.select(&:entity?)
+        end
+
+        def ts_type_full_path
+          if parent.is_a?(CommandGenerator)
+            p = super.dup
+            p[-2] += "Errors"
+            p
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/loaded_entity_generator.rb

@@ -0,0 +1,27 @@
+require_relative "entity_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class LoadedEntityGenerator < EntityGenerator
+        def target_path
+          [*domain.scoped_full_path, "types", entity_name, "Loaded.ts"]
+        end
+
+        def template_path
+          ["Entity", "Loaded.ts.erb"]
+        end
+
+        def ts_instance_path
+          *prefix, name = super
+          [*prefix, "Loaded#{name}"]
+        end
+
+        def ts_instance_full_path
+          *prefix, name = super
+          [*prefix, "Loaded#{name}"]
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/manifest_generator.rb

@@ -0,0 +1,13 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ManifestGenerator < TypescriptFromManifestBaseGenerator
+        def generate(_elements_to_generate)
+          JSON.pretty_generate(relevant_manifest.relevant_manifest)
+        end
+      end
+    end
+  end
+end