foobara-typescript-remote-command-generator 1.2.5 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36ad5c92589d7b37a31298d44d7b3f3ccd6b3537a90d96816d9c35eb8cf7730d
-  data.tar.gz: 1d9d7564f82a39eec11aa36d5f1270a569a2936501ec87694933b67a8aeb6699
+  metadata.gz: 4b6ba29a2e9cc4baa0b854c2af01f8f9765d784d731f71a27d664c09280050c2
+  data.tar.gz: 13e3647fdf41efa57db365b7b2ecb652691491cc720dc605548820e0883f0c60
 SHA512:
-  metadata.gz: '0381acb1520c210bf2c3062c33841e2b90938877d3945b81130232c032f8c00798570bbb460fc48bc344920e4f50f0eb717481676335c063c0517824b2ebd964'
-  data.tar.gz: a51174dd6ef504fcb130c287281b1df30c0c0ffae7e651cc9d8b8718ac10b5d1c594d29e3194b934439c7a35700b2ae342542ab98f45a591c9d51640cd46a39a
+  metadata.gz: c6abab21d2187b784d2cf1887c9b5e7d48b11d440819e4215215f37f5ef9c4ea3df0dd6daa79be1a07733440915b26c62bf340ad16c78b4d93617557d834193b
+  data.tar.gz: 47ce45d8450081c5fc6029f7dc9df67c968103a7e40edda520d2a263452e014cfa54d3123f35ab346002d1bdf490c792ef8419b5cf917f09d47898254c9090f1

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [1.2.7] - 2026-02-16
+
+- Make generated castJsonResult.ts files undefined-safe
+
+## [1.2.6] - 2026-02-16
+
+- Make use of guaranteed_to_exist to avoid marking present delegates as optional
+- Make queries automatically run regardless of inputs presence
+
 ## [1.2.5] - 2026-01-27
 
 - Fix circular dependency that happens if an item from this domain collides

data/src/remote_generator/services/command_cast_result_generator.rb

@@ -116,24 +116,24 @@ module Foobara
                                                          value: "element")
                 result << "})"
               elsif child_cast_tree.is_a?(::Hash)
-                # TODO: either test this codepath or delete it
+                # TODO: either test this code path or delete it
                 # :nocov:
                 property = path_part =~ /\A\d+\z/ ? path_part.to_i : "\"#{path_part}\""
 
                 result << cast_json_result_function_body(child_cast_tree,
                                                          parent:,
                                                          property:,
-                                                         value: "#{parent}.#{path_part}")
+                                                         value: "#{parent}?.#{path_part}")
                 # :nocov:
               elsif child_cast_tree.is_a?(CastTree)
                 result << cast_json_result_function_body(child_cast_tree.children,
-                                                         parent: "#{parent}.#{path_part}")
+                                                         parent: "#{parent}?.#{path_part}")
 
                 property = path_part =~ /\A\d+\z/ ? path_part.to_i : "\"#{path_part}\""
                 result << _ts_cast_expression(child_cast_tree,
                                               parent:,
                                               property:,
-                                              value: "#{parent}.#{path_part}")
+                                              value: "#{parent}?.#{path_part}")
               else
                 # :nocov:
                 raise "Not sure how to handle a #{cast_tree.class}: #{cast_tree}"
@@ -164,9 +164,9 @@ module Foobara
                      if property.nil?
                        parent
                      elsif property =~ /\A"(.*)"\z/
-                       "#{parent}.#{$1}"
+                       "#{parent}?.#{$1}"
                      else
-                       "#{parent}[#{property}]"
+                       "#{parent}?.[#{property}]"
                      end
                    else
                      # TODO: either test this path or raise
@@ -183,21 +183,29 @@ module Foobara
 
           type_symbol = type.type_symbol
 
-          value ||= lvalue
+          value ||= lvalue.dup
+          lvalue = lvalue.gsub("?.[", "[").gsub("?.", ".")
+          present_value = value.gsub("?.[", "[").gsub("?.", ".")
 
-          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.initial)
+          expression = "if (#{value} !== undefined) {\n"
 
-            "#{lvalue} = new #{ts_model_name}(#{value})"
-          else
-            # :nocov:
-            raise "Not sure how to cast type #{type} to a Typescript expression"
-            # :nocov:
-          end
+          expression += if type_symbol == :date || type_symbol == :datetime
+                          "#{lvalue} = new Date(#{present_value})"
+                        elsif type.model?
+                          ts_model_name = model_to_ts_model_name(type,
+                                                                 association_depth:,
+                                                                 initial: cast_tree.initial)
+
+                          "#{lvalue} = new #{ts_model_name}(#{present_value})"
+                        else
+                          # :nocov:
+                          raise "Not sure how to cast type #{type} to a Typescript expression"
+                          # :nocov:
+                        end
+
+          expression += "\n}"
+
+          expression
         end
 
         def _construct_cast_tree(type_declaration, initial: false)

data/src/remote_generator/services/typescript_from_manifest_base_generator.rb

@@ -285,21 +285,26 @@ module Foobara
                               if model_and_entity_free
                                 model_type = type_declaration.to_type
 
-                                translated_type = if type_declaration.detached_entity?
-                                                    model_type.primary_key_type
-                                                  else
-                                                    model_type.attributes_type
-                                                  end
-
-                                foobara_type_to_ts_type(
-                                  translated_type,
-                                  association_depth:,
-                                  dependency_group:,
-                                  initial:,
-                                  model_and_entity_free:,
-                                  is_output:,
-                                  parent: model_type
-                                )
+                                if type_declaration.detached_entity?
+                                  foobara_type_to_ts_type(
+                                    model_type.primary_key_type,
+                                    association_depth:,
+                                    dependency_group:,
+                                    initial:,
+                                    model_and_entity_free:,
+                                    is_output:,
+                                    parent: model_type
+                                  )
+                                else
+                                  attributes_to_ts_type(
+                                    model_type.attributes_type,
+                                    association_depth:,
+                                    dependency_group:,
+                                    model_and_entity_free:,
+                                    is_output:,
+                                    parent: model_type
+                                  )
+                                end
                               else
                                 model_to_ts_model_name(type_declaration, association_depth:, initial:)
                               end
@@ -342,18 +347,22 @@ module Foobara
           # or something.
           if attributes.has_attribute_declarations?
             guts = attributes.attribute_declarations.map do |attribute_name, attribute_declaration|
-              is_required = attributes.required?(attribute_name)
+              exists = attributes.required?(attribute_name)
 
-              if !is_required && is_output
+              if !exists && parent&.model?
+                exists = parent.guaranteed_to_exist?(attribute_name)
+              end
+
+              if !exists && 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
+                  exists = true
                 end
               end
 
-              "  #{attribute_name}#{"?" unless is_required}: #{
+              "  #{attribute_name}#{"?" unless exists}: #{
               foobara_type_to_ts_type(
                 attribute_declaration,
                 dependency_group:,

data/templates/Foobara/Auth/LoginCommand.ts.erb

@@ -7,7 +7,7 @@ export default class LoginCommand<Inputs, Result, Error extends FoobaraError<any
   extends RemoteCommand<Inputs, Result, Error> {
   async _handleResponse (response: Response): Promise<Outcome<Result, Error>> {
     if (response.ok) {
-      const accessToken: string | null = response.headers.get('X-Access-Token')
+      const accessToken: string | null = response.headers.get('x-access-token')
 
       if (accessToken != null) {
         handleLogin(this.urlBase, accessToken)

data/templates/Foobara/Auth/utils/accessTokens.ts.erb

@@ -2,6 +2,7 @@ import type Query from '../../../base/Query'
 import type RemoteCommand from '../../../base/RemoteCommand'
 import { forEachQuery } from '../../../base/QueryCache'
 
+// TODO: Why is this in here? It seems general-purpose not auth-specific
 function dirtyAllQueries () {
   forEachQuery((query: Query<RemoteCommand<any, any, any>>) => {
     query.setDirty()
@@ -10,28 +11,49 @@ function dirtyAllQueries () {
 
 const accessTokens = new Map<string, string>()
 
+interface AuthMessage {
+  type: 'login' | 'logout'
+  baseUrl: string
+}
+
+const login = (baseUrl: string, accessToken: string): void => {
+  accessTokens.set(baseUrl, accessToken)
+  dirtyAllQueries()
+}
+
 const logout = (urlBase: string): void => {
   accessTokens.delete(urlBase)
   dirtyAllQueries()
 }
+
+// These functions gets overridden with a form that broadcasts the event if BroadcastChannel is available
+let handleLogin: (baseUrl: string, accessToken: string) => void = login
 let handleLogout: (baseUrl: string) => void = logout
 
 const tokenForUrl = (baseUrl: string): string | undefined => accessTokens.get(baseUrl)
-const handleLogin: (baseUrl: string, accessToken: string) => void = (baseUrl, accessToken) => {
-  accessTokens.set(baseUrl, accessToken)
-  dirtyAllQueries()
-}
 
 if (typeof BroadcastChannel !== 'undefined') {
   const logoutChannel = new BroadcastChannel('foobara-auth-events')
 
-  logoutChannel.addEventListener('message', (event: MessageEvent<string>) => {
-    accessTokens.delete(event.data)
+  logoutChannel.addEventListener('message', (event: MessageEvent<AuthMessage>) => {
+    const { type, baseUrl } = event.data
+
+    if (type === 'login') {
+      dirtyAllQueries()
+    } else if (type === 'logout') {
+      logout(baseUrl)
+    } else {
+      throw new Error(`Unknown auth message type: ${JSON.stringify(type)}`)
+    }
   })
 
   handleLogout = (baseUrl: string) => {
     logout(baseUrl)
-    logoutChannel.postMessage(baseUrl)
+    logoutChannel.postMessage({ baseUrl, type: 'logout' })
+  }
+  handleLogin = (baseUrl: string, accessToken: string) => {
+    login(baseUrl, accessToken)
+    logoutChannel.postMessage({ baseUrl, type: 'login' })
   }
 }
 

data/templates/base/QueryCache.ts

@@ -16,6 +16,7 @@ export function getQuery<CommandT extends RemoteCommand<any, any, any>> (
   }
 
   let query: Query<CommandT>
+
   if (arguments.length === 2) {
     query = new Query<CommandT>(CommandClass, inputs)
     query.run()

data/templates/hooks/useQuery.ts

@@ -48,12 +48,7 @@ export default function useQuery<CommandT extends RemoteCommand<any, any, any>>
   let query = queryRef.current
 
   if (query == null) {
-    if (arguments.length === 2) {
-      query = getQuery(CommandClass, inputs as InputsOf<CommandT>)
-    } else {
-      query = getQuery(CommandClass)
-    }
-
+    query = getQuery(CommandClass, inputs)
     queryRef.current = query
   }
 

metadata

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