brick 1.0.105 → 1.0.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48fc69654d7cbdf5c7feb9ba7803b7a953c6c0ccd3c176614fe9a61994bb39e1
-  data.tar.gz: f3a4837d334cf97cb491cacd658cb6e6d8e3f3a5c640f80c151a083bf6811b7a
+  metadata.gz: 74bd7cd6539a5f048aecc3e02be8912e1bc77851ac8b9f65402892e964a024de
+  data.tar.gz: c32c53d0012f2a9292463d803d0c679d4f32800c8931c3361469aa22c09a3fc5
 SHA512:
-  metadata.gz: e51134710bae78f033b9dcf7827cd7c087cfd642ef8bc6244e2429f22158a80e9f804022bc703f55fa55f85cbc009ff25440289205ade1b415f5ba0af3d44c77
-  data.tar.gz: d6069676ad70e8401f7597b92b641f0f95e3c28fffa54747f630932500c778d7b4ac967c5bbd70059647d11d398598362d9c0bb5c82ef0500b1025371104a578
+  metadata.gz: f84ee2aae03622a4ca67a6921daf7e975f85601e66fc608c2357613da976414d2ceeec87276887232a832413116ec1495638c883ecc712db3706f51c34efbd44
+  data.tar.gz: e97fbe41eca4d839795f7567bfd3e8a3d6494d4887032fa5f0f87d88ba3c9fdc810bde8a259c3cbf0b8f944c8b345c33290aa5d1e8f7aa67737e7fe7be248a6d

data/lib/brick/config.rb

@@ -95,20 +95,19 @@ module Brick
     end
 
     def api_roots
-      ver = api_version
-      @mutex.synchronize { @api_roots || ["/api/#{ver}/"] }
+      @mutex.synchronize { @api_roots || ["/api/v1/"] }
     end
 
     def api_roots=(path)
       @mutex.synchronize { @api_roots = path }
     end
 
-    def api_version
-      @mutex.synchronize { @api_version || 'v1' }
+    def api_filter
+      @mutex.synchronize { @api_filter }
     end
 
-    def api_version=(ver)
-      @mutex.synchronize { @api_version = ver }
+    def api_filter=(proc)
+      @mutex.synchronize { @api_filter = proc }
     end
 
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)

data/lib/brick/extensions.rb

@@ -1526,9 +1526,10 @@ class Object
         self.protect_from_forgery unless: -> { self.request.format.js? }
         unless is_avo
           self.define_method :index do
+            request_ver = request.path.split('/')[-2]
             current_api_root = ::Brick.config.api_roots.find do |ar|
               request.path.start_with?(ar) || # Exact match?
-              request.path.split('/')[-2] == ar.split('/').last # Version at least matches?
+              request_ver == ar.split('/').last # Version at least matches?
             end
             if (current_api_root || is_openapi) &&
                !params&.key?('_brick_schema') &&
@@ -1542,51 +1543,72 @@ class Object
             _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
 
             if is_openapi
+              api_name = Rswag::Ui.config.config_object[:urls].find do |api_url|
+                api_url[:url] == request.path
+              end&.fetch(:name, 'API documentation')
               current_api_ver = current_api_root.split('/').last&.[](1..-1).to_i
-              json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
+              json = { 'openapi': '3.0.1', 'info': { 'title': api_name, 'version': request_ver },
                        'servers': [
-                         { 'url': '{scheme}://{defaultHost}', 'variables': {
-                           'scheme': { 'default': request.env['rack.url_scheme'] },
-                           'defaultHost': { 'default': request.env['HTTP_HOST'] }
-                         } }
+                         { 'url': '{scheme}://{defaultHost}',
+                           'variables': {
+                             'scheme': { 'default': request.env['rack.url_scheme'] },
+                             'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                           }
+                         }
                        ]
                      }
-              json['paths'] = relations.each_with_object({}) do |relation, s|
-                unless ::Brick.config.enable_api == false
+              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_path = api_vers[current_api_ver])
-
-                  relation_name = api_ver_path || relation.first.tr('.', '/')
-                  table_description = relation.last[:description]
-                  s["#{current_api_root}#{relation_name}"] = {
-                    'get': {
-                      'summary': "list #{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))
-                                        param['description'] = col_descrip
-                                      end
-                                      param
-                                    end,
-                      'responses': { '200': { 'description': 'successful' } }
-                    }
-                  }
-
-                  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
+                          !(api_ver_paths = api_vers[current_api_ver] || api_vers[nil])
+
+                  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]
+                    { :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 |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
+
+                    # 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': relation.last[:cols].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
-                        param
-                      end,
-                      'responses': { '200': { 'description': 'successful' } }
-                    }
-                  } unless relation.last.fetch(:isView, nil)
+                      end
+                    end
+                  end # Do multiple api_ver_paths
                 end
               end
               render inline: json.to_json, content_type: request.format
@@ -1600,11 +1622,11 @@ class Object
               end
               render inline: exported_csv, content_type: request.format
               return
-            elsif request.format == :js || current_api_root # Asking for JSON?
-              # %%% Add:  where, order, page, page_size, offset, limit
-              data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
-              render inline: { data: data }.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
-              return
+            # elsif request.format == :js || current_api_root # Asking for JSON?
+            #   # %%% Add:  where, order, page, page_size, offset, limit
+            #   data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
+            #   render inline: { data: data }.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+            #   return
             end
 
             # Normal (not swagger or CSV) request
@@ -1616,8 +1638,15 @@ class Object
 
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
             @_brick_params = ar_relation.brick_select(params, (selects ||= []), order_by,
-                                                               translations = {},
-                                                               join_array = ::Brick::JoinArray.new)
+                                                      translations = {},
+                                                      join_array = ::Brick::JoinArray.new)
+
+            if request.format == :js || current_api_root # Asking for JSON?
+              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
+              return
+            end
+
             # %%% Add custom HM count columns
             # %%% What happens when the PK is composite?
             counts = model._br_hm_counts.each_with_object([]) do |v, s|
@@ -2127,7 +2156,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
           # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
         fk_references = ActiveRecord::Base.execute_sql(sql)
       when 'SQLite'
-        sql = "SELECT m.name, fkl.\"from\", fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
+        sql = "SELECT NULL AS constraint_schema, m.name, fkl.\"from\", NULL AS primary_schema, fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
         FROM sqlite_master m
           INNER JOIN pragma_foreign_key_list(m.name) fkl ON m.type = 'table'
         ORDER BY m.name, fkl.seq"

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -124,6 +124,8 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
   require 'brick/frameworks/rails'
 end
 module Brick
+  ALL_API_ACTIONS = [:index, :show, :create, :update, :destroy]
+
   class << self
     def sti_models
       @sti_models ||= {}
@@ -347,6 +349,16 @@ module Brick
       Brick.config.api_roots
     end
 
+    # @api public
+    def api_filter=(proc)
+      Brick.config.api_filter = proc
+    end
+
+    # @api public
+    def api_filter
+      Brick.config.api_filter
+    end
+
     # @api public
     def skip_database_views=(value)
       Brick.config.skip_database_views = value
@@ -666,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
@@ -677,49 +692,111 @@ In config/initializers/brick.rb appropriate entries would look something like:
               view_relation = nil
               # 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)
+              if v.key?(:isView) && (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
-                api_ver_num = api_ver[vn_idx + 1..-1].gsub('_', '.').to_i # Attempt to turn something like "v3" into the decimal value 3
+                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
 
-                api_ver_num -= 1 until api_ver_num.zero? ||
-                                       (view_relation = ::Brick.relations.fetch(
-                                         found = "v#{api_ver_num}_#{k[ver.length + 1..-1]}", nil
-                                       ))
+                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".
-                unversioned = "v_#{unversioned}"
-                view_relation ||= ::Brick.relations.fetch(found = unversioned,
-                                                          ::Brick.relations.fetch(found = unversioned, nil)
-                                                         )
-                if found && view_relation && k != (found = unversioned)
-                  view_relation[:api][api_ver_num] = found
-                end
+                no_v_prefix_name = "#{schema_prefix}#{core_object_name}"
+              else
+                unversioned = k
               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
-              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 ||= ::Brick.relations.fetch(found = unversioned, nil) ||
+                                (no_v_prefix_name && ::Brick.relations.fetch(found = no_v_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
+                              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
+                  end
+                  actions &= proc_result[2] if proc_result[2] # allowed_actions
+                end
+                (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
 
@@ -731,7 +808,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.105
+  version: 1.0.107
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -164,6 +164,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.42.0
+- !ruby/object:Gem::Dependency
+  name: rswag-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement