foobara-typescript-remote-command-generator 0.0.1

data/src/remote_generator/services/model_generator.rb

@@ -0,0 +1,84 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ModelGenerator < TypescriptFromManifestBaseGenerator
+        class << self
+          def new(relevant_manifest)
+            return super unless self == ModelGenerator
+
+            if relevant_manifest.entity?
+              EntityGenerator.new(relevant_manifest)
+            else
+              super
+            end
+          end
+        end
+
+        alias model_manifest relevant_manifest
+
+        def target_path
+          [*domain.scoped_full_path, "types", model_name, "#{model_name}.ts"]
+        end
+
+        def template_path
+          ["Model", "Model.ts.erb"]
+        end
+
+        def scoped_full_path(points = nil)
+          full_path = model_manifest.scoped_full_path
+
+          if points
+            start_at = full_path.size - points - 1
+            full_path[start_at..]
+          else
+            full_path
+          end
+        end
+
+        def model_name(points = nil)
+          if points
+            scoped_full_path(points).join(".")
+          else
+            scoped_path.join(".")
+          end
+        end
+
+        # Do models have associations??
+        def model_generators
+          types_depended_on.select(&:model?).map do |model|
+            Services::ModelGenerator.new(model)
+          end
+        end
+
+        def dependencies
+          model_generators
+        end
+
+        def model_name_downcase
+          model_name[0].downcase + model_name[1..]
+        end
+
+        def attributes_type_ts_type
+          association_depth = AssociationDepth::AMBIGUOUS
+          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+        end
+
+        def atom_attributes_ts_type
+          association_depth = AssociationDepth::ATOM
+          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+        end
+
+        def aggregate_attributes_ts_type
+          association_depth = AssociationDepth::AGGREGATE
+          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+        end
+
+        def attribute_names
+          attributes_type.attribute_names
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/model_manifest_generator.rb

@@ -0,0 +1,11 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ModelManifestGenerator < ManifestGenerator
+        def target_path
+          [*domain.scoped_full_path, "types", model_name, "manifest.json"]
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/model_variants_generator.rb

@@ -0,0 +1,35 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ModelVariantsGenerator < ModelGenerator
+        def target_path
+          [*domain.scoped_full_path, "types", "#{model_name}.ts"]
+        end
+
+        def template_path
+          "ModelVariants.ts.erb"
+        end
+
+        def model_generator
+          ModelGenerator.new(model_manifest)
+        end
+
+        def atom_model_generator
+          AtomModelGenerator.new(model_manifest)
+        end
+
+        def aggregate_model_generator
+          AggregateModelGenerator.new(model_manifest)
+        end
+
+        def dependencies
+          if has_associations?
+            [model_generator, atom_model_generator, aggregate_model_generator]
+          else
+            [model_generator]
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/organization_config_generator.rb

@@ -0,0 +1,21 @@
+require_relative "organization_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class OrganizationConfigGenerator < OrganizationGenerator
+        def target_path
+          [*super[0..-2], "config.ts"]
+        end
+
+        def template_path
+          "Organization/config.ts.erb"
+        end
+
+        def dependencies
+          []
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/organization_generator.rb

@@ -0,0 +1,41 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class OrganizationGenerator < TypescriptFromManifestBaseGenerator
+        alias organization_manifest relevant_manifest
+
+        def import_destructure
+          "* as #{organization_name}"
+        end
+
+        def target_path
+          if global?
+            ["GlobalOrganization", "index.ts"]
+          else
+            [*scoped_full_path, "index.ts"]
+          end
+        end
+
+        def template_path
+          "Organization.ts.erb"
+        end
+
+        def domain_generators
+          @domain_generators ||= organization_manifest.domains.map do |domain_manifest|
+            DomainGenerator.new(domain_manifest)
+          end
+        end
+
+        def dependencies
+          domain_generators
+        end
+
+        def organization_name
+          scoped_short_name || "GlobalOrganization"
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/organization_manifest_generator.rb

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

data/src/remote_generator/services/processor_class_generator.rb

@@ -0,0 +1,18 @@
+require_relative "typescript_from_manifest_base_generator"
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class ProcessorClassGenerator < TypescriptFromManifestBaseGenerator
+        alias processor_class_manifest relevant_manifest
+
+        def target_path
+          *path, basename = scoped_full_path
+          basename = "#{basename}.ts"
+
+          ["base", "processors", *path, basename]
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/root_manifest_generator.rb

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

data/src/remote_generator/services/typescript_from_manifest_base_generator.rb

@@ -0,0 +1,293 @@
+# Where to put files?
+# let's examine an error...
+# if an error belongs to a command, let's put it in <command path>/errors/<error_name>.ts
+# if an error belongs to a domain, let's put it in <domain path>/errors/<error_name>.ts
+# if an error belongs to an organization, let's put it in <organization path>/errors/<error_name>.ts
+# if an error belongs to a base processor, let's put it in base/processors/<processor path>/<error_name>.ts
+# if an error belongs to nothing, let's put it in errors/<error_name>.ts
+#
+# so what is the official logic?
+# if parent is a domain or org or nil,
+# then we need to insert "errors" before the last element in the scoped_path.
+# This is to help make the commands more first-class.
+# otherwise, the thing will already be out of site. We could prepend the path with "base" and <parent_category>.
+#
+# Might just be safer though to leverage the parent's target_dir.
+#
+# So that logic would be...
+# if parent is domain, nil, or org:
+# <parent_target_dir>/errors/<error_name>.ts
+# else
+# <parent_target_dir>/<error_name>.ts
+
+module Foobara
+  module RemoteGenerator
+    class Services
+      class TypescriptFromManifestBaseGenerator < Foobara::FilesGenerator
+        class << self
+          def manifest_to_generator_classes(manifest)
+            case manifest
+            when Manifest::Command
+              [
+                Services::CommandGenerator,
+                Services::CommandInputsGenerator,
+                Services::CommandResultGenerator,
+                Services::CommandErrorsGenerator,
+                Services::CommandErrorsIndexGenerator,
+                Services::CommandManifestGenerator
+              ]
+            when Manifest::Domain
+              [
+                Services::DomainGenerator,
+                Services::DomainConfigGenerator,
+                Services::DomainManifestGenerator
+              ]
+            when Manifest::Organization
+              [
+                Services::OrganizationGenerator,
+                Services::OrganizationConfigGenerator,
+                Services::OrganizationManifestGenerator
+              ]
+            when Manifest::Entity
+              [
+                Services::EntityGenerator,
+                Services::EntityVariantsGenerator,
+                Services::EntityManifestGenerator
+              ]
+            when Manifest::Model
+              [
+                Services::ModelGenerator,
+                Services::ModelVariantsGenerator,
+                Services::ModelManifestGenerator
+              ]
+            when Manifest::Error
+              Services::ErrorGenerator
+            when Manifest::ProcessorClass
+              Services::ProcessorClassGenerator
+            when Manifest::RootManifest
+              Services::RootManifestGenerator
+            else
+              # :nocov:
+              raise "Not sure how build a generator for a #{manifest}"
+              # :nocov:
+            end
+          end
+        end
+
+        def initialize(relevant_manifest)
+          unless relevant_manifest.is_a?(Manifest::BaseManifest)
+            # :nocov:
+            raise ArgumentError, "Expected a Foobara::Manifest, got #{relevant_manifest.class}"
+            # :nocov:
+          end
+
+          super
+        end
+
+        def templates_dir
+          "#{__dir__}/../../../templates"
+        end
+
+        def parent
+          if relevant_manifest.parent
+            generator_for(relevant_manifest.parent)
+          end
+        end
+
+        def dependency_group
+          @dependency_group ||= begin
+            generators = dependencies.map do |dependency|
+              generator_for(dependency)
+            end
+
+            DependencyGroup.new(generators, name: scoped_full_path.join("."))
+          end
+        end
+
+        def dependency_roots
+          unless dependency_group
+            # :nocov:
+            raise "This generator was created without a " \
+                  "dependency_group and therefore cannot call #{__method__}"
+            # :nocov:
+          end
+
+          dependency_group.non_colliding_dependency_roots.sort_by(&:scoped_full_name)
+        end
+
+        def ts_instance_name
+          ts_instance_path.join(".")
+        end
+
+        def ts_instance_path
+          scoped_path
+        end
+
+        def ts_instance_full_name
+          ts_instance_full_path.join(".")
+        end
+
+        def ts_instance_full_path
+          scoped_full_path
+        end
+
+        def ts_type_full_path
+          ts_instance_full_path
+        end
+
+        foobara_delegate :organization_name,
+                         :domain_name,
+                         to: :relevant_manifest
+
+        def import_path
+          if import_path_array.size == 1
+            "./#{import_path_array.first}"
+          else
+            import_path_array.join("/")
+          end
+        end
+
+        def import_destructure
+          "{ #{scoped_name} }"
+        end
+
+        def import_path_array
+          path = if target_path.last == "index.ts"
+                   target_path[0..-2]
+                 else
+                   target_path
+                 end
+
+          path[-1] = path.last.gsub(/\.ts$/, "")
+
+          path
+        end
+
+        def value_to_ts_value(value)
+          case value
+          when ::String, Numeric
+            value.inspect
+          when ::Symbol
+            value.to_s.inspect
+          else
+            # :nocov:
+            raise "Not sure how to represent #{value} in typescript. Maybe implement it."
+            # :nocov:
+          end
+        end
+
+        # TODO: relocate this to a more reusable place
+        def foobara_type_to_ts_type(
+          type_declaration,
+          dependency_group: self.dependency_group,
+          name: nil,
+          association_depth: AssociationDepth::AMBIGUOUS,
+          initial: true
+        )
+          if type_declaration.is_a?(Manifest::Error)
+            error_generator = generator_for(type_declaration)
+            return dependency_group.non_colliding_type(error_generator)
+          end
+
+          type_string = if type_declaration.is_a?(Manifest::Attributes)
+                          ts_type = attributes_to_ts_type(type_declaration, association_depth:, dependency_group:)
+
+                          if name
+                            return "interface #{name} #{ts_type}"
+                          else
+                            ts_type
+                          end
+                        elsif type_declaration.is_a?(Manifest::Array)
+                          # TODO: which association_depth do we pass here?
+                          ts_type = foobara_type_to_ts_type(
+                            type_declaration.element_type,
+                            association_depth:,
+                            dependency_group:,
+                            initial: false
+                          )
+                          "#{ts_type}[]"
+                        else
+                          type_symbol = type_declaration.type
+
+                          case type_symbol
+                          when "string", "boolean"
+                            type_symbol
+                          when "number", "integer", "float"
+                            "number"
+                          # TODO: should apply relevant processors to make email a real email type instead of "string"
+                          when "symbol", "email"
+                            "string"
+                          when "duck"
+                            "any"
+                          when "datetime"
+                            "Date"
+                          else
+                            if type_declaration.model?
+                              model_to_ts_model_name(type_declaration, association_depth:, initial:)
+                            end
+                          end
+                        end
+
+          if type_string
+            if type_declaration.one_of
+              type_string = type_declaration.one_of.map(&:inspect).join(" | ")
+            end
+
+            if type_declaration.allows_nil?
+              type_string = "#{type_string} | null"
+            end
+
+            name ? "#{name} = #{type_string}" : type_string
+          else
+            # :nocov:
+            raise "Not sure how to convert #{type_declaration} to a TS type"
+            # :nocov:
+          end
+        end
+
+        def attributes_to_ts_type(attributes, dependency_group:, association_depth: AssociationDepth::AMBIGUOUS)
+          guts = attributes.attribute_declarations.map do |attribute_name, attribute_declaration|
+            "  #{attribute_name}#{"?" unless attributes.required?(attribute_name)}: #{
+              foobara_type_to_ts_type(attribute_declaration, dependency_group:, association_depth:, initial: false)
+            }"
+          end.join("\n")
+
+          "{\n#{guts}\n}"
+        end
+
+        def model_to_ts_model_name(model, association_depth: AssociationDepth::AMBIGUOUS, initial: true)
+          model = model.to_type if model.is_a?(Manifest::TypeDeclaration)
+
+          generator_class = case association_depth
+                            when AssociationDepth::AMBIGUOUS
+                              Services::ModelGenerator
+                            when AssociationDepth::ATOM
+                              if !initial && model.entity?
+                                Services::UnloadedEntityGenerator
+                              else
+                                Services::AtomModelGenerator
+                              end
+                            when AssociationDepth::AGGREGATE
+                              Services::AggregateModelGenerator
+                            else
+                              # :nocov:
+                              raise "Bad association_depth: #{association_depth}"
+                              # :nocov:
+                            end
+
+          generator = generator_class.new(model)
+
+          dependency_group.non_colliding_type(generator)
+        end
+
+        def ==(other)
+          self.class == other.class && path == other.path && root_manifest == other.root_manifest
+        end
+
+        def hash
+          path.hash
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/unloaded_entity_generator.rb

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

data/src/remote_generator/write_typescript_to_disk.rb

@@ -0,0 +1,78 @@
+require_relative "generate_typescript"
+
+module Foobara
+  module RemoteGenerator
+    class WriteTypescriptToDisk < Generators::WriteGeneratedFilesToDisk
+      class << self
+        def generator_key
+          "typescript-remote-commands"
+        end
+      end
+
+      # TODO: shouldn't have to qualify DataError like this
+      class MissingManifestError < Value::DataError
+        class << self
+          def context_type_declaration
+            {}
+          end
+        end
+      end
+
+      possible_error MissingManifestError
+
+      inputs do
+        raw_manifest :associative_array, :allow_nil
+        manifest_url :string, :allow_nil
+        # TODO: should be able to delete this and inherit it
+        output_directory :string, default: "src/domains"
+      end
+
+      depends_on GenerateTypescript
+
+      def execute
+        generate_typescript
+        generate_generated_files_json
+        delete_old_files_if_needed
+        write_all_files_to_disk
+        run_post_generation_tasks
+
+        stats
+      end
+
+      def validate
+        if raw_manifest.nil? && manifest_url.nil?
+          add_input_error(
+            MissingManifestError.new(
+              message: "Must provide either raw_manifest or manifest_url",
+              context: {}
+            )
+          )
+        end
+      end
+
+      def generate_typescript
+        # TODO: we need a way to allow values to be nil in type declarations
+        inputs = raw_manifest ? { raw_manifest: } : { manifest_url: }
+
+        self.paths_to_source_code = run_subcommand!(GenerateTypescript, inputs)
+      end
+
+      def run_post_generation_tasks
+        eslint_fix
+      end
+
+      def eslint_fix
+        cmd = "npx eslint 'src/**/*.{js,jsx,ts,tsx}' --fix"
+
+        Open3.popen3(cmd) do |_stdin, _stdout, stderr, wait_thr|
+          exit_status = wait_thr.value
+          unless exit_status.success?
+            # :nocov:
+            warn "WARNING: could not #{cmd}\n#{stderr.read}"
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator.rb

@@ -0,0 +1,5 @@
+module Foobara
+  module RemoteGenerator
+    foobara_domain!
+  end
+end

data/templates/Command/Errors.ts.erb

@@ -0,0 +1,11 @@
+<% dependency_roots.each do |dependency_root| %>
+import <%= dependency_root.import_destructure %> from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface PossibleErrors {
+<% possible_errors.keys.sort.each do |key| %>
+  "<%= key %>": <%= foobara_type_to_ts_type(possible_errors[key].error, dependency_group:) %>,
+<% end  %>
+}
+
+export type Error = <%= error_type_union %>

data/templates/Command/Inputs.ts.erb

@@ -0,0 +1,5 @@
+<% dependency_roots.each do |dependency_root| %>
+  import <%= dependency_root.import_destructure %> from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export default <%= foobara_type_to_ts_type(inputs_type, name: "Inputs", dependency_group:) %>

data/templates/Command/Result.ts.erb

@@ -0,0 +1,7 @@
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.ts_instance_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+type Result = <%= foobara_type_to_ts_type(result_type, dependency_group:, association_depth:) %>
+
+export default Result

data/templates/Command/errors/index.ts.erb

@@ -0,0 +1,3 @@
+<% errors_in_this_namespace.each do |error_generator| %>
+export <%= error_generator.import_destructure %> from "<%= path_to_root %><%= error_generator.import_path %>"
+<% end %>