Fix DeepHashAccessor#[] and generate typed nested resource classes

codegen/layouts/resource.hbs

@@ -2,13 +2,42 @@
 
 module Seam
   module Resources
+{{#each nestedClasses}}
+    class {{className}} < BaseResource
+{{#each accessors}}
+{{#if description}}
+{{{rubyDoc description 6}}}
+{{/if}}
+      attr_accessor :{{name}}
+{{/each}}
+{{#each dateAccessors}}
+{{#if description}}
+{{{rubyDoc description 6}}}
+{{/if}}
+      date_accessor :{{name}}
+{{/each}}
+{{#each resourceAccessors}}
+      resource_accessor :{{name}}, {{className}}
+{{/each}}
+{{#each resourceListAccessors}}
+      resource_list_accessor :{{name}}, {{className}}
+{{/each}}
+    end
+
+{{/each}}
 {{#if resource.description}}
 {{{rubyDoc resource.description 4}}}
 {{/if}}
 {{#if resource.isDeprecated}}
 {{{rubyDeprecatedDoc resource 4}}}
 {{/if}}
     class {{className}} < BaseResource
+{{#each resourceAccessors}}
+      resource_accessor :{{name}}, {{className}}
+{{/each}}
+{{#each resourceListAccessors}}
+      resource_list_accessor :{{name}}, {{className}}
+{{/each}}
 {{#each accessors}}
 {{#if description}}
 {{{rubyDoc description 6}}}

codegen/lib/layouts/resource.ts

@@ -5,6 +5,17 @@ import type { Property } from '@seamapi/blueprint'
 import { pascalCase } from 'change-case'
 
 import { convertCustomResourceName } from '../custom-resource-name-conversions.js'
+import { mergeProperties } from '../merge-properties.js'
+
+type ResourceAccessor = Property & Documented & { className: string }
+
+interface NestedClass {
+  className: string
+  accessors: Array<Property & Documented>
+  dateAccessors: Array<Property & Documented>
+  resourceAccessors: ResourceAccessor[]
+  resourceListAccessors: ResourceAccessor[]
+}
 
 export interface ResourceLayoutContext {
   className: string
@@ -14,6 +25,9 @@ export interface ResourceLayoutContext {
   hasSupportModules: boolean
   includeErrorsSupport: boolean
   includeWarningsSupport: boolean
+  nestedClasses: NestedClass[]
+  resourceAccessors: ResourceAccessor[]
+  resourceListAccessors: ResourceAccessor[]
 }
 
 interface Documented {
@@ -44,17 +58,91 @@ export const setResourceLayoutContext = (
   const includeErrorsSupport = attrs.includes('errors')
   const includeWarningsSupport = attrs.includes('warnings')
 
+  const rootClassName = pascalCase(convertCustomResourceName(snakeName))
+  const nestedClasses = new Map<string, NestedClass>()
+
+  const buildClass = (
+    className: string,
+    classProperties: Property[],
+  ): NestedClass => {
+    const resourceAccessors: ResourceAccessor[] = []
+    const resourceListAccessors: ResourceAccessor[] = []
+
+    for (const property of classProperties) {
+      if (property.name === 'errors' || property.name === 'warnings') continue
+
+      let nestedProperties: Property[] | undefined
+      let destination = resourceAccessors
+      if (property.format === 'object') {
+        nestedProperties = property.properties
+      } else if (
+        property.format === 'list' &&
+        property.itemFormat === 'object'
+      ) {
+        nestedProperties = property.itemProperties
+        destination = resourceListAccessors
+      } else if (
+        property.format === 'list' &&
+        property.itemFormat === 'discriminated_object'
+      ) {
+        nestedProperties = mergeProperties(
+          property.variants.map((variant) => variant.properties),
+        )
+        destination = resourceListAccessors
+      }
+
+      if (nestedProperties == null) continue
+      const nestedClassName = `${rootClassName}${pascalCase(property.name)}`
+      destination.push({ ...property, className: nestedClassName })
+      if (!nestedClasses.has(nestedClassName)) {
+        const nestedClass = buildClass(nestedClassName, nestedProperties)
+        nestedClasses.set(nestedClassName, nestedClass)
+      }
+    }
+
+    const typedNames = new Set(
+      [...resourceAccessors, ...resourceListAccessors].map(({ name }) => name),
+    )
+    return {
+      className,
+      accessors: classProperties.filter(
+        (property) =>
+          property.format !== 'datetime' && !typedNames.has(property.name),
+      ),
+      dateAccessors: classProperties.filter(
+        (property) => property.format === 'datetime',
+      ),
+      resourceAccessors,
+      resourceListAccessors,
+    }
+  }
+
+  const parentClass = buildClass(rootClassName, properties)
+  const parentTypedNames = new Set(
+    [
+      ...parentClass.resourceAccessors,
+      ...parentClass.resourceListAccessors,
+    ].map(({ name }) => name),
+  )
+
   return {
-    className: pascalCase(convertCustomResourceName(snakeName)),
+    className: rootClassName,
     resource,
     accessors: properties
-      .filter((property) => noErrorWarningAttrs.includes(property.name))
+      .filter(
+        (property) =>
+          noErrorWarningAttrs.includes(property.name) &&
+          !parentTypedNames.has(property.name),
+      )
       .map((property) => property),
     dateAccessors: properties
       .filter((property) => dateAttrs.includes(property.name))
       .map((property) => property),
     hasSupportModules: includeErrorsSupport || includeWarningsSupport,
     includeErrorsSupport,
     includeWarningsSupport,
+    nestedClasses: [...nestedClasses.values()],
+    resourceAccessors: parentClass.resourceAccessors,
+    resourceListAccessors: parentClass.resourceListAccessors,
   }
 }

codegen/lib/merge-properties.ts

@@ -0,0 +1,11 @@
+import type { Property } from '@seamapi/blueprint'
+
+export const mergeProperties = (propertyLists: Property[][]): Property[] => {
+  const merged = new Map<string, Property>()
+  for (const properties of propertyLists) {
+    for (const property of properties) {
+      if (!merged.has(property.name)) merged.set(property.name, property)
+    }
+  }
+  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name))
+}

codegen/lib/routes.ts

@@ -21,6 +21,7 @@ import { setClientLayoutContext } from './layouts/client.js'
 import { setImportsLayoutContext } from './layouts/imports.js'
 import { setResourceLayoutContext } from './layouts/resource.js'
 import { setRoutesFileLayoutContext } from './layouts/routes-file.js'
+import { mergeProperties } from './merge-properties.js'
 import type { ClientMethod, ClientModel } from './ruby-client.js'
 import {
   resourceErrorRb,
@@ -153,16 +154,6 @@ const getResources = (
   return [...resources.entries()].sort(([a], [b]) => a.localeCompare(b))
 }
 
-const mergeProperties = (propertyLists: Property[][]): Property[] => {
-  const merged = new Map<string, Property>()
-  for (const properties of propertyLists) {
-    for (const property of properties) {
-      if (!merged.has(property.name)) merged.set(property.name, property)
-    }
-  }
-  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name))
-}
-
 interface ClientSource {
   name: string
   parentPath: string | null

codegen/lib/static-resources.ts

@@ -34,6 +34,11 @@ export const resourceErrorsSupportRb = `# frozen_string_literal: true
 module Seam
   module Resources
     module ResourceErrorsSupport
+      def update_from_response(data)
+        @errors_converted = nil
+        super
+      end
+
       def errors
         @errors_converted ||= @errors.is_a?(Array) ? Seam::Resources::ResourceError.load_from_response(@errors) : []
       end
@@ -47,6 +52,11 @@ export const resourceWarningsSupportRb = `# frozen_string_literal: true
 module Seam
   module Resources
     module ResourceWarningsSupport
+      def update_from_response(data)
+        @warnings_converted = nil
+        super
+      end
+
       def warnings
         @warnings_converted ||= @warnings.is_a?(Array) ? Seam::Resources::ResourceWarning.load_from_response(@warnings) : []
       end

lib/seam/base_resource.rb

@@ -20,6 +20,8 @@ def update_from_response(data)
       end
 
       def self.load_from_response(data, client = nil)
+        return nil if data.nil?
+
         if data.is_a?(Array)
           data.map { |d| new(d, client) }
         else
@@ -36,6 +38,31 @@ def inspect
             .join("\n") + ">"
       end
 
+      def [](key)
+        name = key.to_s
+        return nil unless respond_to?(name)
+
+        public_send(name)
+      end
+
+      def self.resource_accessor(attr, resource_class)
+        resource_accessors[attr.to_s] = resource_class
+        attr_accessor attr
+      end
+
+      def self.resource_list_accessor(attr, resource_class)
+        resource_list_accessors[attr.to_s] = resource_class
+        attr_accessor attr
+      end
+
+      def self.resource_accessors
+        @resource_accessors ||= {}
+      end
+
+      def self.resource_list_accessors
+        @resource_list_accessors ||= {}
+      end
+
       def self.date_accessor(*attrs)
         attrs.each do |attr|
           define_method(attr) do
@@ -54,7 +81,17 @@ def parse_datetime(value)
 
       def process_data_attributes(data)
         data.each do |key, value|
-          value = process_hash_value(value)
+          next unless key.to_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+
+          resource_class = self.class.resource_accessors[key.to_s]
+          resource_list_class = self.class.resource_list_accessors[key.to_s]
+          value = if resource_class && value.is_a?(Hash)
+            resource_class.load_from_response(value, client)
+          elsif resource_list_class && value.is_a?(Array)
+            resource_list_class.load_from_response(value, client)
+          else
+            process_hash_value(value)
+          end
           instance_variable_set(:"@#{key}", value)
         end
       end

lib/seam/deep_hash_accessor.rb

@@ -10,7 +10,12 @@ def initialize(data)
     end
 
     def [](key)
-      instance_variable_get(:"@#{key}")
+      # Subscript access is Hash-like and returns nil for unknown keys, while
+      # method access continues to raise NoMethodError.
+      name = key.to_s
+      return nil unless respond_to?(name)
+
+      public_send(name)
     end
 
     def to_h
@@ -21,9 +26,8 @@ def to_h
 
     def create_accessor_methods
       @data.each do |key, value|
-        define_singleton_method(key) do
-          process_value(value)
-        end
+        processed = process_value(value)
+        define_singleton_method(key) { processed }
       end
     end