brick 1.0.106 → 1.0.108

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 988907627ce35c257a41cbcf4b455ec852c9635fe4f8721c5af167e416fbb4ef
-  data.tar.gz: c4a2fe612aa26a628f347d830197f961cf21b67c825ff968fa589e6bd342d1d7
+  metadata.gz: 1e9a085e3f9ba811623d8ebc5d840018348d207b6b1ecab97c066894c44c6ab0
+  data.tar.gz: 83f32dc71791730d7370f3375b3c19e6cc00e8062efe5b01bdb4cf5aa40b92b9
 SHA512:
-  metadata.gz: 3488a28db2bf8f3c7f363e9b2eb4355e9de2d4021db9a39fb45656f896046bee412a7fd310861f522915bbc244af35a2707005757357ee6b9f9877ea331e7240
-  data.tar.gz: 8a44cbbadde246520b028d0e474226cdf2d43e8d51bed023e20f21a0d5b6cc0e690a397908bcdbdb9b7ef21c7743bec64130258b859d1583b6c0facffd8edf5f
+  metadata.gz: dda58c12995437cb95ce60224543d64ef2ed16b0792a083e0def39e7be4569ceaaad86098f6470daf45c358db1d10a1ff350195c0c61ccd3363cbcfae0c344c2
+  data.tar.gz: 673a82fbbd268c4c8ba590c8eb980fe6e71a62caff710d32ff3b21b3c67927a22ec02380d5d8f8366a1dcadaece238aab3e737f92e879de9da5893dcde0251fa

data/lib/brick/config.rb

@@ -110,6 +110,50 @@ module Brick
       @mutex.synchronize { @api_filter = proc }
     end
 
+    # # Proc gets called with up to 4 arguments:  object_name, api_version, columns, data
+    # # Expected to return an array, either just of symbols defining column names, or an array with two sub-arrays, first of column detail and second of data
+    # def api_column_filter
+    #   @mutex.synchronize { @api_column_filter }
+    # end
+
+    # def api_column_filter=(proc)
+    #   @mutex.synchronize { @api_column_filter = proc }
+    # end
+
+    # Allows you to rename and exclude columns either specific to a given API version, or generally for a database object name
+    def api_column_renaming
+      @mutex.synchronize { @api_column_renaming }
+    end
+
+    def api_column_renaming=(renames)
+      @mutex.synchronize { @api_column_renaming = renames }
+    end
+
+    # All the view prefix things
+    def api_view_prefix
+      @mutex.synchronize { @api_view_prefix }
+    end
+
+    def api_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_view_prefix = view_prefix }
+    end
+
+    def api_remove_view_prefix
+      @mutex.synchronize { @api_remove_view_prefix || @api_view_prefix }
+    end
+
+    def api_remove_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_remove_view_prefix = view_prefix }
+    end
+
+    def api_add_view_prefix
+      @mutex.synchronize { @api_add_view_prefix || @api_view_prefix }
+    end
+
+    def api_add_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_add_view_prefix = view_prefix }
+    end
+
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)
     def additional_references
       @mutex.synchronize { @additional_references }

data/lib/brick/extensions.rb

@@ -44,16 +44,20 @@
 
 module ActiveRecord
   class Base
-    def self.is_brick?
-      instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
-    end
+    class << self
+      attr_reader :_brick_relation
 
-    def self._assoc_names
-      @_assoc_names ||= {}
-    end
+      def is_brick?
+        instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+      end
 
-    def self.is_view?
-      false
+      def _assoc_names
+        @_assoc_names ||= {}
+      end
+
+      def is_view?
+        false
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -787,21 +791,21 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
         end
         self.order_values |= final_order_by # Same as:  order!(*final_order_by)
       end
-      if (page = params['_brick_page']&.to_i)
-        page = 1 if page < 1
-        limit = params['_brick_page_size'] || 1000
-        offset = (page - 1) * limit.to_i
-      else
-        offset = params['_brick_offset']
-        limit = params['_brick_limit']
-      end
+      # By default just 1000 rows
+      row_limit = params['_brick_limit'] || params['_brick_page_size'] || 1000
+      offset = if (page = params['_brick_page']&.to_i)
+                 page = 1 if page < 1
+                 (page - 1) * row_limit.to_i
+               else
+                 params['_brick_offset']
+               end
       if offset.is_a?(Numeric) || offset&.present?
         offset = offset.to_i
         self.offset_value = offset unless offset == 0
-        @_brick_page_num = (offset / limit.to_i) + 1 if limit&.!= 0 && (offset % limit.to_i) == 0
+        @_brick_page_num = (offset / row_limit.to_i) + 1 if row_limit&.!= 0 && (offset % row_limit.to_i) == 0
       end
-      # By default just 1000 rows  (Like doing:  limit!(1000)  but this way is compatible with AR <= 4.2)
-      self.limit_value = limit&.to_i || 1000 unless limit.is_a?(String) && limit.empty?
+      # Setting limit_value= is the same as doing:  limit!(1000)  but this way is compatible with AR <= 4.2
+      self.limit_value = row_limit.to_i unless row_limit.is_a?(String) && row_limit.empty?
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
@@ -1261,6 +1265,7 @@ class Object
       # Having this separate -- will this now work out better?
         built_model.class_exec do
           @_brick_built = true
+          @_brick_relation = relation
           hmts&.each do |hmt_fk, hms|
             hmt_fk = hmt_fk.tr('.', '_')
             hms.each do |hm|
@@ -1560,44 +1565,62 @@ class Object
               unless ::Brick.config.enable_api == false
                 json['paths'] = relations.each_with_object({}) do |relation, s|
                   next if (api_vers = relation.last.fetch(:api, nil)) &&
-                          !(api_ver_paths = api_vers[current_api_ver])
+                          !(api_ver_paths = api_vers[current_api_ver] || api_vers[nil])
 
-                  # binding.pry if relation.last.fetch(:isView, nil) && api_ver_paths != { relation.first => ::Brick::ALL_API_ACTIONS }
-                  (api_ver_paths || { relation.first => ::Brick::ALL_API_ACTIONS }).each do |api_ver_path, actions|
-                    relation_name = api_ver_path || relation.first.tr('.', '/')
+                  schema_tag = {}
+                  if (schema_name = relation.last&.fetch(:schema, nil))
+                    schema_tag['tags'] = [schema_name]
+                  end
+                  all_actions = relation.last.key?(:isView) ? [:index, :show] : ::Brick::ALL_API_ACTIONS
+                  (api_ver_paths || { relation.first => all_actions }).each do |api_ver_path, actions|
+                    relation_name = (api_ver_path || relation.first).tr('.', '/')
                     table_description = relation.last[:description]
-                    unless actions&.exclude?(:index)
-                      s["#{current_api_root}#{relation_name}"] = {
-                        'get': {
-                          'summary': "list #{relation.first}",
+
+                    # Column renaming / exclusions
+                    renamed_columns = if (column_renaming = ::Brick.find_col_renaming(api_ver_path, relation.first))
+                                        column_renaming.each_with_object({}) do |rename, s|
+                                          s[rename.last] = relation.last[:cols][rename.first] if rename.last
+                                        end
+                                      else
+                                        relation.last[:cols]
+                                      end
+                    { :index => [:get, 'list'], :create => [:post, 'create a'] }.each do |k, v|
+                      unless actions&.exclude?(k)
+                        this_resource = (s["#{current_api_root}#{relation_name}"] ||= {})
+                        this_resource[v.first] = {
+                          'summary': "#{v[1]} #{relation.first}",
                           'description': table_description,
-                          'parameters': relation.last[:cols].map do |k, v|
-                                          param = { in: 'query', 'name' => k, 'schema': { 'type': v.first } }
-                                          if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                          'parameters': renamed_columns.map do |k2, v2|
+                                          param = { in: 'query', 'name': k2, 'schema': { 'type': v2.first } }
+                                          if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k2, nil))
                                             param['description'] = col_descrip
                                           end
                                           param
                                         end,
                           'responses': { '200': { 'description': 'successful' } }
-                        }
-                      }
+                        }.merge(schema_tag)
+                      end
                     end
 
-                    unless actions&.exclude?(:update)
-                      s["#{current_api_root}#{relation_name}/{id}"] = {
-                        'patch': {
-                          'summary': "update a #{relation.first.singularize}",
-                          'description': table_description,
-                          'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                            param = { 'name' => k, 'schema': { 'type': v.first } }
-                            if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                              param['description'] = col_descrip
-                            end
-                            param
-                          end,
-                          'responses': { '200': { 'description': 'successful' } }
-                        }
-                      } unless relation.last.fetch(:isView, nil)
+                    # We have not yet implemented the #show action
+                    if (id_col = relation.last[:pkey]&.values&.first&.first) # ... ID-dependent stuff
+                      { :update => [:patch, 'update'], :destroy => [:delete, 'delete'] }.each do |k, v|
+                        unless actions&.exclude?(k)
+                          this_resource = (s["#{current_api_root}#{relation_name}/{#{id_col}}"] ||= {})
+                          this_resource[v.first] = {
+                            'summary': "#{v[1]} a #{relation.first.singularize}",
+                            'description': table_description,
+                            'parameters': renamed_columns.reject { |k1, _v1| Brick.config.metadata_columns.include?(k1) }.map do |k2, v2|
+                              param = { 'name': k2, 'schema': { 'type': v2.first } }
+                              if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k2, nil))
+                                param['description'] = col_descrip
+                              end
+                              param
+                            end,
+                            'responses': { '200': { 'description': 'successful' } }
+                          }.merge(schema_tag)
+                        end
+                      end
                     end
                   end # Do multiple api_ver_paths
                 end
@@ -1633,8 +1656,38 @@ class Object
                                                       join_array = ::Brick::JoinArray.new)
 
             if request.format == :js || current_api_root # Asking for JSON?
+              # Apply column renaming
               data = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects) : ar_relation.select(selects)
-              render inline: { data: data }.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+              if data.present? &&
+                 (column_renaming = ::Brick.find_col_renaming(current_api_root, model&._brick_relation)&.select { |cr| cr.last })
+                data.map!({}) do |row, s|
+                  column_renaming.each_with_object({}) do |rename, s|
+                    s[rename.last] = row[rename.first] if rename.last
+                  end
+                end
+              end
+
+              # %%% Still need to figure out column filtering and transformations
+              # proc_result = if (column_filter = ::Brick.config.api_column_filter).is_a?(Proc)
+              #                 object_columns = relation.last[:cols]
+              #                 begin
+              #                   num_args = column_filter.arity.negative? ? 5 : column_filter.arity
+              #                   # object_name, api_version, columns, data
+              #                   column_filter.call(*[relation.first, api_ver_path, object_columns, nil][0...num_args])
+              #                 rescue StandardError => e
+              #                   puts "::Brick.api_column_filter Proc error: #{e.message}"
+              #                 end
+              #               end
+              # columns = if (proc_result) # Proc returns up to 2 things:  columns, data
+              #             # If it's all valid column name strings then we're just rearranging the column sequence
+              #             col_names = proc_result.all? { |pr| object_columns.key?(pr) } ? proc_result : proc_result.first.keys
+              #             col_names.each_with_object({}) { |cn, s| s[cn] = relation.last[:cols][cn] }
+              #           else
+              #             relation.last[:cols]
+              #           end
+              # binding.pry
+
+              render inline: { data: data }.to_json, content_type: ['*/*', 'text/html'].include?(request.format) ? 'application/json' : request.format
               return
             end
 
@@ -2594,6 +2647,11 @@ module Brick
       end
     end
 
+    def find_col_renaming(api_ver_path, relation_name)
+      (column_renames = ::Brick.config.api_column_renaming&.fetch(api_ver_path, nil) ||
+                        ::Brick.config.api_column_renaming)&.fetch(relation_name, nil)
+    end
+
     def _class_pk(dotted_name, multitenant)
       Object.const_get((multitenant ? [dotted_name.split('.').last] : dotted_name.split('.')).map { |nm| "::#{nm.singularize.camelize}" }.join).primary_key
     end

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 106
+    TINY = 108
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -678,7 +678,10 @@ In config/initializers/brick.rb appropriate entries would look something like:
           ::Brick.relations.each do |k, v|
             next if !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
 
-            schema_name = v.fetch(:schema, nil)
+            object_name = k.split('.').last # Take off any first schema part
+            if (schema_name = v.fetch(:schema, nil))
+              schema_prefix = "#{schema_name}."
+            end
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
             # First do the API routes if necessary
@@ -686,100 +689,125 @@ In config/initializers/brick.rb appropriate entries would look something like:
             ::Brick.api_roots&.each do |api_root|
               api_done_views = (versioned_views[api_root] ||= {})
               found = nil
+              test_ver_num = nil
               view_relation = nil
-              actions = ::Brick::ALL_API_ACTIONS # By default all actions are allowed
               # If it's a view then see if there's a versioned one available by searching for resource names
               # versioned with the closest number (equal to or less than) compared with our API version number.
-              if v.key?(:isView) && (ver = k.match(/^v([\d_]*)/).captures.first)[-1] == '_'
-                next if api_done_views.key?(unversioned = k[ver.length + 1..-1])
-
-                # # if ().length.positive? # Does it have a version number?
-                # try_num = (ver_num = (ver = ver[1..-1].gsub('_', '.')).to_d)
-
-                # Expect that the last item in the path generally holds versioning information
-                api_ver = api_root.split('/')[-1]&.gsub('_', '.')
-                vn_idx = api_ver.rindex(/[^\d._]/) # Position of the first numeric digit at the end of the version number
-                # Was:  .to_d
-                test_ver_num = api_ver_num = api_ver[vn_idx + 1..-1].gsub('_', '.').to_i # Attempt to turn something like "v3" into the decimal value 3
-                # puts [api_ver, vn_idx, api_ver_num, unversioned].inspect
-
-                next if ver.to_i > api_ver_num # Don't surface any newer views in an older API
-
-                test_ver_num -= 1 until test_ver_num.zero? ||
-                                        (view_relation = ::Brick.relations.fetch(
-                                         found = "v#{test_ver_num}_#{k[ver.length + 1..-1]}", nil
-                                        ))
-                api_done_views[unversioned] = nil # Mark that for this API version this view is done
-
-                # puts "Found #{found}" if view_relation
-                # If we haven't found "v3_view_name" or "v2_view_name" or so forth, at the last
-                # fall back to simply looking for "v_view_name", and then finally  "view_name".
-                unversioned = "v_#{unversioned}"
-                view_relation ||= ::Brick.relations.fetch(found = unversioned,
-                                                          ::Brick.relations.fetch(found = unversioned, nil)
-                                                         )
-                if found && view_relation && k != unversioned
-                  # Call proc that limits which endpoints get surfaced based on version, table or view name, method (get list / get one / post / patch / delete)
-                  # Returning nil makes it do nothing, false makes it skip creating this endpoint, and an array of up to
-                  # these 3 things controls and changes the nature of the endpoint that gets built:
-                  # (updated api_name, name of different relation to route to, allowed actions such as :index, :show, :create, etc)
-                  proc_result = if (filter = ::Brick.config.api_filter).is_a?(Proc)
-                                  begin
-                                    filter.call(unversioned, k, actions, api_ver_num, found, test_ver_num)
-                                  rescue StandardError => e
-                                    puts "::Brick.api_filter Proc error: #{e.message}"
-                                  end
+              if v.key?(:isView)
+                if (ver = object_name.match(/^v([\d_]*)/)&.captures&.first) && ver[-1] == '_'
+                  core_object_name = object_name[ver.length + 1..-1]
+                  next if api_done_views.key?(unversioned = "#{schema_prefix}v_#{core_object_name}")
+
+                  # Expect that the last item in the path generally holds versioning information
+                  api_ver = api_root.split('/')[-1]&.gsub('_', '.')
+                  vn_idx = api_ver.rindex(/[^\d._]/) # Position of the first numeric digit at the end of the version number
+                  # Was:  .to_d
+                  test_ver_num = api_ver_num = api_ver[vn_idx + 1..-1].gsub('_', '.').to_i # Attempt to turn something like "v3" into the decimal value 3
+                  # puts [api_ver, vn_idx, api_ver_num, unversioned].inspect
+
+                  next if ver.to_i > api_ver_num # Don't surface any newer views in an older API
+
+                  test_ver_num -= 1 until test_ver_num.zero? ||
+                                          (view_relation = ::Brick.relations.fetch(
+                                            found = "#{schema_prefix}v#{test_ver_num}_#{core_object_name}", nil
+                                          ))
+                  api_done_views[unversioned] = nil # Mark that for this API version this view is done
+
+                  # puts "Found #{found}" if view_relation
+                  # If we haven't found "v3_view_name" or "v2_view_name" or so forth, at the last
+                  # fall back to simply looking for "v_view_name", and then finally  "view_name".
+                  no_v_prefix_name = "#{schema_prefix}#{core_object_name}"
+                  standard_prefix = 'v_'
+                else
+                  core_object_name = object_name
+                end
+                if (rvp = ::Brick.config.api_remove_view_prefix) && core_object_name.start_with?(rvp)
+                  core_object_name.slice!(0, rvp.length)
+                end
+                no_prefix_name = "#{schema_prefix}#{core_object_name}"
+                unversioned = "#{schema_prefix}#{standard_prefix}#{::Brick.config.api_add_view_prefix}#{core_object_name}"
+              else
+                unversioned = k
+              end
+
+              view_relation ||= ::Brick.relations.fetch(found = unversioned, nil) ||
+                                (no_v_prefix_name && ::Brick.relations.fetch(found = no_v_prefix_name, nil)) ||
+                                (no_prefix_name && ::Brick.relations.fetch(found = no_prefix_name, nil))
+              if view_relation
+                actions = view_relation.key?(:isView) ? [:index, :show] : ::Brick::ALL_API_ACTIONS # By default all actions are allowed
+                # Call proc that limits which endpoints get surfaced based on version, table or view name, method (get list / get one / post / patch / delete)
+                # Returning nil makes it do nothing, false makes it skip creating this endpoint, and an array of up to
+                # these 3 things controls and changes the nature of the endpoint that gets built:
+                # (updated api_name, name of different relation to route to, allowed actions such as :index, :show, :create, etc)
+                proc_result = if (filter = ::Brick.config.api_filter).is_a?(Proc)
+                                begin
+                                  num_args = filter.arity.negative? ? 6 : filter.arity
+                                  filter.call(*[unversioned, k, actions, api_ver_num, found, test_ver_num][0...num_args])
+                                rescue StandardError => e
+                                  puts "::Brick.api_filter Proc error: #{e.message}"
                                 end
-                  # proc_result expects to receive back: [updated_api_name, to_other_relation, allowed_actions]
-
-                  case proc_result
-                  when NilClass
-                    # Do nothing differently than what normal behaviour would be
-                  when FalseClass # Skip implementing this endpoint
-                    view_relation[:api][api_ver_num] = nil
-                    next
-                  when Array # Did they give back an array of actions?
-                    unless proc_result.any? { |pr| ::Brick::ALL_API_ACTIONS.exclude?(pr) }
-                      proc_result = [unversioned, to_relation, proc_result]
-                    end
-                    # Otherwise don't change this array because it's probably legit
-                  when String
-                    proc_result = [proc_result] # Treat this as the surfaced api_name (path) they want to use for this endpoint
-                  else
-                    puts "::Brick.api_filter Proc warning: Unable to parse this result returned: \n  #{proc_result.inspect}"
-                    proc_result = nil # Couldn't understand what in the world was returned
+                              end
+                # proc_result expects to receive back: [updated_api_name, to_other_relation, allowed_actions]
+
+                case proc_result
+                when NilClass
+                  # Do nothing differently than what normal behaviour would be
+                when FalseClass # Skip implementing this endpoint
+                  view_relation[:api][api_ver_num] = nil
+                  next
+                when Array # Did they give back an array of actions?
+                  unless proc_result.any? { |pr| ::Brick::ALL_API_ACTIONS.exclude?(pr) }
+                    proc_result = [unversioned, to_relation, proc_result]
                   end
+                  # Otherwise don't change this array because it's probably legit
+                when String
+                  proc_result = [proc_result] # Treat this as the surfaced api_name (path) they want to use for this endpoint
+                else
+                  puts "::Brick.api_filter Proc warning: Unable to parse this result returned: \n  #{proc_result.inspect}"
+                  proc_result = nil # Couldn't understand what in the world was returned
+                end
 
-                  if proc_result&.present?
-                    if proc_result[1] # to_other_relation
-                      if (new_view_relation = ::Brick.relations.fetch(proc_result[1], nil))
-                        k = proc_result[1] # Route this call over to this different relation
-                        view_relation = new_view_relation
-                      else
-                        puts "::Brick.api_filter Proc warning: Unable to find new suggested relation with name #{proc_result[1]} -- sticking with #{k} instead."
-                      end
-                    end
-                    if proc_result.first&.!=(k) # updated_api_name -- a different name than this relation would normally have
-                      found = proc_result.first
+                if proc_result&.present?
+                  if proc_result[1] # to_other_relation
+                    if (new_view_relation = ::Brick.relations.fetch(proc_result[1], nil))
+                      k = proc_result[1] # Route this call over to this different relation
+                      view_relation = new_view_relation
+                    else
+                      puts "::Brick.api_filter Proc warning: Unable to find new suggested relation with name #{proc_result[1]} -- sticking with #{k} instead."
                     end
-                    actions &= proc_result[2] if proc_result[2] # allowed_actions
                   end
+                  if proc_result.first&.!=(k) # updated_api_name -- a different name than this relation would normally have
+                    found = proc_result.first
+                  end
+                  actions &= proc_result[2] if proc_result[2] # allowed_actions
                 end
-                (view_relation[:api][api_ver_num] ||= {})[found] = actions # Add to the list of API paths this resource responds to
-              end
-
-              # view_ver_num = if (first_part = k.split('_').first) =~ /^v[\d_]+/
-              #                  first_part[1..-1].gsub('_', '.').to_i
-              #                end
-              controller_name = view_relation.fetch(:resource, nil)&.pluralize if view_relation
-              # %%% So far we can only surface the #index action
-              if actions.include?(:index)
-                if schema_name
-                  full_resource = "#{schema_name}/#{found || v[:resource]}"
-                  send(:get, "#{api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" })
-                else
-                  # Normally goes to something like:  /api/v1/employees
-                  send(:get, "#{api_root}#{found || v[:resource]}", { to: "#{controller_prefix}#{controller_name}#index" })
+                (view_relation[:api][api_ver_num] ||= {})[unversioned] = actions # Add to the list of API paths this resource responds to
+
+                # view_ver_num = if (first_part = k.split('_').first) =~ /^v[\d_]+/
+                #                  first_part[1..-1].gsub('_', '.').to_i
+                #                end
+
+                controller_name = if (last = view_relation.fetch(:resource, nil)&.pluralize)
+                                    "#{schema_prefix}#{last}"
+                                  else
+                                    found
+                                  end.tr('.', '/')
+
+                { :index => 'get', :create => 'post' }.each do |action, method|
+                  if actions.include?(action)
+                    # Normally goes to something like:  /api/v1/employees
+                    send(method, "#{api_root}#{unversioned.tr('.', '/')}", { to: "#{controller_prefix}#{controller_name}##{action}" })
+                  end
+                end
+                # %%% We do not yet surface the #show action
+                if (id_col = view_relation[:pk]&.first) # ID-dependent stuff
+                  { :update => ['put', 'patch'], :destroy => ['delete'] }.each do |action, methods|
+                    if actions.include?(action)
+                      methods.each do |method|
+                        send(method, "#{api_root}#{unversioned.tr('.', '/')}/:#{id_col}", { to: "#{controller_prefix}#{controller_name}##{action}" })
+                      end
+                    end
+                  end
                 end
               end
             end
@@ -792,7 +820,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
               else
                 table_class_length = class_name.length if class_name.length > table_class_length
                 tables
-              end << [class_name, full_resource || v[:resource]]
+              end << [class_name, "#{schema_prefix&.tr('.', '/')}#{v[:resource]}"]
             end
 
             # Now the normal routes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.106
+  version: 1.0.108
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-18 00:00:00.000000000 Z
+date: 2023-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord