foobara-typescript-remote-command-generator 1.1.6 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ded6d4d4e950f079230273d922ef380455597c4dd0fcf01005396156871291e
-  data.tar.gz: 9f2ff8044bd23a32c5db7768a4783e17c3be1742f43edf7d6c60664935e9ff1f
+  metadata.gz: 9f783af32070cfcdc33c70d34c1b755a66a0a6bb3df7b7e8697345bdc1d148f7
+  data.tar.gz: fdcfa71700d34b3c42163b586fc2f8cb1c90f420bef3fb76f7a8a5a8d29e6423
 SHA512:
-  metadata.gz: 4447f6d43c30e80f514c8db191bbf8bb115ded65df4febaa030c877bffd88db7820db66d637185353e7bb7aab81d666dc38002d5413d99358f5a07e217fdcbfc
-  data.tar.gz: 4929a9a0ccb737f0df18979adcfc7d3d223c272c810f44aef208441b01077b77fcde6a114e0f822347530a39774c5bd06b0d2463ddb6503835a18d3853ea7449
+  metadata.gz: b5b5d35cc80f88622f2a4ea321574a7af55e9c61ec7bde32d42761a9d9511af07ced97894f4905962bb1803c1871d9a8ab4c9c83722df5caefffe7342b90e474
+  data.tar.gz: 6d0a1fcb787dc719a330bd58953d42e387f931b35a2eb3d6168ab0d0dfbdec166a1f2215339ea7046b3edfc00473365cdca75e6846408014ed96a3f04d6ef3d8

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [1.2.0] - 2025-11-06
+
+- If an attribute isn't required but has a default, it will have a non-required create
+  interface but a required read interface. This updates the types to reflect that for
+  convenience to avoid pointless null checks.
+
+## [1.1.7] - 2025-11-02
+
+- Make CommandCastResultGenerator's interpretation of atom? match other generators
+
 ## [1.1.6] - 2025-10-17
 
 - Dirty all queries on login/logout, not just GetCurrentUser

data/src/remote_generator/services/command_cast_result_generator.rb

@@ -5,12 +5,12 @@ module Foobara
     class Services
       class CommandCastResultGenerator < CommandResultGenerator
         class CastTree
-          attr_accessor :children, :declaration_to_cast, :past_first_model
+          attr_accessor :children, :declaration_to_cast, :initial
 
-          def initialize(children: nil, declaration_to_cast: nil, past_first_model: false)
+          def initialize(children: nil, declaration_to_cast: nil, initial: false)
             self.children = children
             self.declaration_to_cast = declaration_to_cast
-            self.past_first_model = past_first_model
+            self.initial = initial
           end
 
           def empty?
@@ -41,31 +41,30 @@ module Foobara
 
           nested_model_generators = []
 
-          generators = model_generators
-
-          generators.each do |generator|
-            _models_reachable_from_declaration(
-              generator.relevant_manifest
-            )&.each do |(model, past_first)|
-              generator_class = if atom?
-                                  if model.detached_entity? && past_first
-                                    Services::UnloadedEntityGenerator
-                                  else
-                                    Services::AtomModelGenerator
-                                  end
-                                elsif aggregate?
-                                  Services::AggregateModelGenerator
+          if result_type.detached_entity? && atom?
+            declaration = result_type.is_a?(Manifest::TypeDeclaration) ? result_type.to_type : result_type
+            return @nested_model_generators = Set[Services::AtomEntityGenerator.new(declaration)]
+          end
+
+          _models_reachable_from_declaration(result_type, initial: true)&.each do |model|
+            generator_class = if atom?
+                                if model.detached_entity?
+                                  Services::UnloadedEntityGenerator
                                 else
-                                  Services::ModelGenerator
+                                  Services::AtomModelGenerator
                                 end
+                              elsif aggregate?
+                                Services::AggregateModelGenerator
+                              else
+                                Services::ModelGenerator
+                              end
 
-              new_generator = generator_class.new(model)
+            new_generator = generator_class.new(model)
 
-              unless generators.any? do |g|
-                g.relevant_manifest == model && g.class == new_generator.class
-              end
-                nested_model_generators << new_generator
-              end
+            unless nested_model_generators.any? do |g|
+              g.relevant_manifest == model && g.class == new_generator.class
+            end
+              nested_model_generators << new_generator
             end
           end
 
@@ -81,7 +80,7 @@ module Foobara
         end
 
         def dependencies
-          @dependencies ||= model_generators + nested_model_generators
+          nested_model_generators
         end
 
         def cast_json_result_function
@@ -92,7 +91,7 @@ module Foobara
 
         # TODO: need to make use of initial?
         def cast_json_result_function_body(
-          cast_tree = _construct_cast_tree(result_type),
+          cast_tree = _construct_cast_tree(result_type, initial: true),
           parent: "json",
           property: nil,
           value: parent
@@ -189,8 +188,9 @@ module Foobara
           if type_symbol == :date || type_symbol == :datetime
             "#{lvalue} = new Date(#{value})"
           elsif type.model?
-            ts_model_name = model_to_ts_model_name(type, association_depth:,
-                                                         initial: !cast_tree.past_first_model)
+            ts_model_name = model_to_ts_model_name(type,
+                                                   association_depth:,
+                                                   initial: cast_tree.initial)
 
             "#{lvalue} = new #{ts_model_name}(#{value})"
           else
@@ -200,7 +200,7 @@ module Foobara
           end
         end
 
-        def _construct_cast_tree(type_declaration, past_first_model: false)
+        def _construct_cast_tree(type_declaration, initial: false)
           if type_declaration.is_a?(Manifest::Attributes)
             return unless type_declaration.has_attribute_declarations?
             return if type_declaration.attribute_declarations.empty?
@@ -209,39 +209,39 @@ module Foobara
 
             type_declaration.attribute_declarations.each_pair do |attribute_name, attribute_declaration|
               if type_requires_cast?(attribute_declaration)
-                path_tree[attribute_name] = _construct_cast_tree(attribute_declaration, past_first_model:)
+                path_tree[attribute_name] = _construct_cast_tree(attribute_declaration)
               end
             end
 
             unless path_tree.empty?
-              CastTree.new(children: path_tree, past_first_model:)
+              CastTree.new(children: path_tree, initial:)
             end
           elsif type_declaration.is_a?(Manifest::Array)
             element_type = type_declaration.element_type
 
             if element_type && type_requires_cast?(element_type)
-              CastTree.new(children: { "#": _construct_cast_tree(element_type, past_first_model:) })
+              CastTree.new(initial:, children: { "#": _construct_cast_tree(element_type) })
             end
           elsif type_declaration.type.to_sym == :date || type_declaration.type.to_sym == :datetime
-            CastTree.new(declaration_to_cast: type_declaration, past_first_model:)
+            CastTree.new(declaration_to_cast: type_declaration, initial:)
           elsif type_declaration.model?
             type_declaration = type_declaration.to_type
 
             children = if type_declaration.detached_entity? && atom?
                          nil
                        else
-                         _construct_cast_tree(type_declaration.attributes_type, past_first_model: true)
+                         _construct_cast_tree(type_declaration.attributes_type)
                        end
 
-            CastTree.new(children:, declaration_to_cast: type_declaration, past_first_model:)
+            CastTree.new(children:, declaration_to_cast: type_declaration, initial:)
             # TODO: either test this code path or raise or delete it
             # :nocov:
           elsif type_declaration.custom?
             if type_requires_cast?(type_declaration.base_type.to_type_declaration)
-              tree = _construct_cast_tree(type_declaration.base_type.to_type_declaration, past_first_model:)
+              tree = _construct_cast_tree(type_declaration.base_type.to_type_declaration)
 
               if tree && !tree.empty?
-                CastTree.new(children: tree, past_first_model:)
+                CastTree.new(children: tree, initial:)
               end
             end
           end
@@ -249,7 +249,7 @@ module Foobara
         end
 
         # TODO: Feels like similar complicated logic is popping up in many places? How to find/converge such logic
-        def _models_reachable_from_declaration(type_declaration, past_first_model: false)
+        def _models_reachable_from_declaration(type_declaration, initial: false)
           if type_declaration.is_a?(Manifest::Attributes)
             return unless type_declaration.has_attribute_declarations?
             return if type_declaration.attribute_declarations.empty?
@@ -258,13 +258,14 @@ module Foobara
 
             type_declaration.attribute_declarations.each_value do |attribute_declaration|
               if type_requires_cast?(attribute_declaration)
-                models ||= Set.new
-
-                _models_reachable_from_declaration(
-                  attribute_declaration,
-                  past_first_model:
-                )&.each do |pair|
-                  models << pair
+                additional = _models_reachable_from_declaration(attribute_declaration)
+
+                if additional
+                  if models
+                    models |= additional
+                  else
+                    models = additional
+                  end
                 end
               end
             end
@@ -274,24 +275,23 @@ module Foobara
             element_type = type_declaration.element_type
 
             if element_type && type_requires_cast?(element_type)
-              _models_reachable_from_declaration(element_type, past_first_model:)
+              _models_reachable_from_declaration(element_type)
             end
           elsif type_declaration.model?
             if type_declaration.is_a?(Manifest::TypeDeclaration)
               type_declaration = type_declaration.to_type
             end
 
-            models = Set[[type_declaration, past_first_model]]
+            models = Set[type_declaration]
 
             if atom? && type_declaration.detached_entity?
               return models
             end
 
-            _models_reachable_from_declaration(
-              type_declaration.attributes_type,
-              past_first_model: true
-            )&.each do |pair|
-              models << pair
+            additional = _models_reachable_from_declaration(type_declaration.attributes_type)
+
+            if additional
+              models |= additional
             end
 
             models
@@ -299,10 +299,7 @@ module Foobara
             # TODO: either test this code path or raise or delete it
             # :nocov:
             if type_requires_cast?(type_declaration.base_type.to_type_declaration)
-              _models_reachable_from_declaration(
-                type_declaration.base_type.to_type_declaration,
-                past_first_model:
-              )
+              _models_reachable_from_declaration(type_declaration.base_type.to_type_declaration)
             end
             # :nocov:
           end

data/src/remote_generator/services/type_generator.rb

@@ -120,17 +120,29 @@ module Foobara
 
         def attributes_type_ts_type
           association_depth = AssociationDepth::AMBIGUOUS
-          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+          foobara_type_to_ts_type(attributes_type,
+                                  association_depth:,
+                                  dependency_group:,
+                                  is_output: true,
+                                  parent: relevant_manifest)
         end
 
         def atom_attributes_ts_type
           association_depth = AssociationDepth::ATOM
-          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+          foobara_type_to_ts_type(attributes_type,
+                                  association_depth:,
+                                  dependency_group:,
+                                  is_output: true,
+                                  parent: relevant_manifest)
         end
 
         def aggregate_attributes_ts_type
           association_depth = AssociationDepth::AGGREGATE
-          foobara_type_to_ts_type(attributes_type, association_depth:, dependency_group:)
+          foobara_type_to_ts_type(attributes_type,
+                                  association_depth:,
+                                  dependency_group:,
+                                  is_output: true,
+                                  parent: relevant_manifest)
         end
 
         def attribute_names

data/src/remote_generator/services/typescript_from_manifest_base_generator.rb

@@ -194,14 +194,19 @@ module Foobara
           end
         end
 
-        # TODO: relocate this to a more reusable place
+        # is_output means the value came from elsewhere and is fully formed.
+        # This is helpful for specifying what is expected to be present. If this is provided,
+        # then things like attribute properties that have defaults will be considered
+        # required and present.
         def foobara_type_to_ts_type(
           type_declaration,
           dependency_group: self.dependency_group,
           name: nil,
           association_depth: AssociationDepth::AMBIGUOUS,
           initial: true,
-          model_and_entity_free: false
+          model_and_entity_free: false,
+          is_output: false,
+          parent: nil
         )
           if type_declaration.is_a?(Manifest::Error)
             error_generator = generator_for(type_declaration)
@@ -213,7 +218,9 @@ module Foobara
                             type_declaration,
                             association_depth:,
                             dependency_group:,
-                            model_and_entity_free:
+                            model_and_entity_free:,
+                            is_output:,
+                            parent:
                           )
 
                           if type_declaration.has_attribute_declarations?
@@ -241,7 +248,8 @@ module Foobara
                             association_depth:,
                             dependency_group:,
                             initial: false,
-                            model_and_entity_free:
+                            model_and_entity_free:,
+                            is_output:
                           )
                           "#{ts_type}[]"
                         else
@@ -275,7 +283,9 @@ module Foobara
                                   association_depth:,
                                   dependency_group:,
                                   initial:,
-                                  model_and_entity_free:
+                                  model_and_entity_free:,
+                                  is_output:,
+                                  parent: model_type
                                 )
                               else
                                 model_to_ts_model_name(type_declaration, association_depth:, initial:)
@@ -310,20 +320,34 @@ module Foobara
           attributes,
           dependency_group:,
           association_depth: AssociationDepth::AMBIGUOUS,
-          model_and_entity_free: false
+          model_and_entity_free: false,
+          is_output: false,
+          parent: nil
         )
           # TODO: if we don't actually have attribute_declarations because we
           # are trying to express attributes of any type, then we want Record<string, any>
           # or something.
           if attributes.has_attribute_declarations?
             guts = attributes.attribute_declarations.map do |attribute_name, attribute_declaration|
-              "  #{attribute_name}#{"?" unless attributes.required?(attribute_name)}: #{
+              is_required = attributes.required?(attribute_name)
+
+              if !is_required && is_output
+                default = attributes.default_for(attribute_name)
+
+                if default || default == false ||
+                   (parent&.detached_entity? && attribute_name == parent.primary_key_name.to_sym)
+                  is_required = true
+                end
+              end
+
+              "  #{attribute_name}#{"?" unless is_required}: #{
               foobara_type_to_ts_type(
                 attribute_declaration,
                 dependency_group:,
                 association_depth:,
                 initial: false,
-                model_and_entity_free:
+                model_and_entity_free:,
+                is_output:
               )
             }"
             end.join("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-typescript-remote-command-generator
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.2.0
 platform: ruby
 authors:
 - Miles Georgi