model_driven_api 3.1.10 → 3.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0afb3dc1dca5b7277c7ea2bfd601669765d5227fe68ede17fa6fbfc3de19d36f
-  data.tar.gz: 02c3ece69e6237b42f8f04de6660469d528c81a84cf392a34a743360b765d832
+  metadata.gz: bbaf42c9a62f9ebdc9cdf60633aeeb47ad39b11e9ebb9d20a94af73fea6c7213
+  data.tar.gz: c56851d1ae81777a20cc1d7ea26c0a31fb2f349933df72e41f303b8194cc8da6
 SHA512:
-  metadata.gz: 92c3d537101cb23123ce34564eaac4fe1d767770628dddcd1cc94487253bb82c880e07721a78c2be3dc571c370020b12e13ab30e9981d035c7766634dccdeb7b
-  data.tar.gz: 69385bf1c20fe26e8168be63da529edb847002984084e133e431aef6b07815bb88edf1f42ed43d65dc0ef5194a28ede011c29f05aca3de0176dd11a119da3a8a
+  metadata.gz: 67ff210a1024a027db62fdaad0091b52229b36d61753ee95c128930a3e4ea8bd127bc1bf8e61209a7aac9938b0c32fd768cdd8b72548adf7f8cc1336b41c95e6
+  data.tar.gz: fc5a82329178979b349055efb02840708ee1d2df4a3ea37d19f9b317403a5d583a584c25f712e3a72c83d438d344d46fbcfb8762bfa573d40909f991e8716fc6

data/app/controllers/api/v2/info_controller.rb

@@ -515,49 +515,17 @@ class Api::V2::InfoController < Api::V2::ApplicationController
           }
         }
         # Non CRUD or Search, but custom, usually bulk operations endpoints
-        custom_actions = d.methods(false).select do |m| m.to_s.starts_with?("custom_action_") end
-        # Add also custom actions created using th enew Endpoints Interface
-        custom_actions += "Endpoints::#{d.model_name.name}".constantize.methods(false) rescue []
-        custom_actions.each do |action|
-          custom_action_name = action.to_s.gsub("custom_action_", "")
-          pivot["/#{model}/custom_action/#{custom_action_name}"] = {
-            "get": {
-              "summary": "Custom Action #{custom_action_name.titleize}",
-              "description": "This is just an example of a custom action, they can accept a wide range of payloads and response with a wide range of responses, also all verbs are valid. Please refer to the documentation for more information.",
-              "tags": [model.classify],
-              "security": [
-                "bearerAuth": []
-              ],
-              "responses": {
-                "200": {
-                  "description": "Custom Action",
-                  "content": {
-                    "application/json": {
-                      "schema": {
-                        "type": "object",
-                        "properties": {
-                          "id": {
-                            "type": "integer"
-                          },
-                          "created_at": {
-                            "type": "string",
-                            "format": "date-time"
-                          },
-                          "updated_at": {
-                            "type": "string",
-                            "format": "date-time"
-                          }
-                        }
-                      }
-                    }
-                  }
-                },
-                "404": {
-                  "description": "No #{model} found"
-                }
-              }
-            }
-          }
+        new_custom_actions = ("Endpoints::#{d.model_name.name}".constantize.instance_methods(false) rescue [])
+        # Rails.logger.debug "New Custom Actions (#{d.model_name.name}): #{new_custom_actions}"
+        new_custom_actions.each do |action|
+          openapi_definition = "Endpoints::#{d.model_name.name}".constantize.definitions[action.to_sym] rescue false
+          
+          # Add the tag to the openapi definition
+          openapi_definition.each do |k, v|
+            v[:tags] = [ d.model_name.name ]
+          end
+
+          pivot["/#{model}/custom_action/#{action}"] = openapi_definition if openapi_definition
         end
         pivot["/#{model}/search"] = {
           # Complex queries are made using ranskac search via a post endpoint

data/app/models/endpoints/test_api.rb

@@ -1,56 +1,78 @@
 class Endpoints::TestApi < NonCrudEndpoints
-  def test(params)
-    # Define an explain var to be used to validate and document the action behavior when using ?explain=true in query string
-    explain = {
-      verbs: ["GET", "POST"],
-      body: {
-        messages: {
-          type: :array,
-          optional: true,
-          items: {
-            type: :string,
-            optional: false
+  self.desc :test, {
+    # Define the action name using openapi swagger format
+    get: {
+      summary: "Test API Custom Action",
+      description: "This is a test API custom action",
+      operationId: "test",
+      tags: ["Test"],
+      parameters: [
+        {
+          name: "explain",
+          in: "query",
+          description: "Explain the action by returning this openapi schema",
+          required: true,
+          schema: {
+            type: "boolean"
           }
-        },
-        is_connected: {
-          type: :boolean,
-          optional: false
-        },
-        user: {
-          type: :object,
-          optional: true,
-          properties: {
-            name: {
-              type: :string,
-              optional: false
-            },
-            age: {
-              type: :integer,
-              optional: true
+        }
+      ],
+      responses: {
+        200 => {
+          description: "The openAPI json schema for this action",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                additionalProperties: true
+              }
             }
           }
+        },
+        501 => {
+          error: :string,
         }
-      },
-      query: {
-        explain: {
-          type: :boolean,
-          optional: true
+      }
+    },
+    post: {
+      summary: "Test API Custom Action",
+      description: "This is a test API custom action",
+      operationId: "test",
+      tags: ["Test"],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {}
         }
       },
       responses: {
         200 => {
-          message: :string,
-          params: {},
+          description: "The openAPI json schema for this action",
+          # This will return the object with a message string and a params object
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  message: {
+                    type: "string"
+                  },
+                  params: {
+                    type: "object",
+                    additionalProperties: true
+                  }
+                }
+              }
+            }
+          }
         },
         501 => {
           error: :string,
-        },
-      },
+        }
+      }
     }
-    return explain, 200 if params[:explain].to_s == "true" && !explain.blank?
-    
-    
+  }
+  def test(params)    
     return { message: "Hello World From Test API Custom Action called test", params: params }, 200
   end
 end
-# end

data/lib/model_driven_api/version.rb

@@ -1,3 +1,3 @@
 module ModelDrivenApi
-  VERSION = "3.1.10".freeze
+  VERSION = "3.1.11".freeze
 end

data/lib/non_crud_endpoints.rb

@@ -1,37 +1,45 @@
 class NonCrudEndpoints
     attr_accessor :result
+    cattr_accessor :definitions
+    self.definitions = {}
     # Add a validation method which will be inherited by all the instances, and automatically run before any method call
     def initialize(m, params)
         # Check if self hase the m method, if not, raise a NoMethodError
-        raise NoMethodError, "The method #{m} does not exist in #{self.class}" unless self.respond_to? m
-        definition = self.send(m, { explain: true }) rescue []
-        validate_request(definition.first.presence || {}, params)
+        raise NoMethodError, "The method #{m} does not exist in #{self.class.name}" unless self.respond_to? m
+        @definition = self.definitions[m.to_sym].with_indifferent_access
+
+        # self.send(m, { explain: true }) rescue []
+        validate_request(params)
         @result = self.send(m, params)
     end
 
-    def validate_request(definition, params)
+    def validate_request(params)
         # If there is no definition, return
-        return if definition.blank?
+        return if @definition.blank?
         # puts "Called Class is: #{self.class}"
         # puts "Which is son of: #{self.class.superclass}"
-        body_mandatory_keys = definition[:body].select { |k, v| v[:optional] == false }.keys
-        query_mandatory_keys = definition[:query].select { |k, v| v[:optional] == false }.keys
-        # Raise a ValidationError if the request does not match the definition
-        raise EndpointValidationError, "The verb \"#{params[:request_verb].presence || "No Verb Provided"}\" is not present in #{definition[:verbs].join(", ")}." if definition[:verbs].exclude? params[:request_verb]
-        # Raise an exception if the verb is put or post and the body keys in definition are not all present as params keys, both params and definition[:body] can have nested objects
-        raise EndpointValidationError, "The request body does not match the definition: in #{params[:request_verb]} requests all of the params must be present in definition. The body definition is #{definition[:body]}." if params[:request_verb] != "GET" && (body_mandatory_keys & params.keys) != body_mandatory_keys
-        # Raise an exception if the verb is put or post and the body keys in definition are not all present as params keys, both params and definition[:body] can have nested objects
-        raise EndpointValidationError, "The request query does not match the definition. The query definition is: #{definition[:query]}." if (query_mandatory_keys & params.keys) != query_mandatory_keys
-        # Rais if the type of the param is not the same as the definition
-        definition[:body].each do |k, v|
-            next if params[k].nil?
-            computed_type = get_type(params[k])
-            raise EndpointValidationError, "The type of the param #{k} is not the same as the definition. The definition is #{v[:type]} and the param is #{computed_type}." if v[:type] != computed_type
-        end
+        # body_mandatory_keys = definition[:body].select { |k, v| v[:optional] == false }.keys
+        # query_mandatory_keys = definition[:query].select { |k, v| v[:optional] == false }.keys
+        # # Raise a ValidationError if the request does not match the definition
+        # raise EndpointValidationError, "The verb \"#{params[:request_verb].presence || "No Verb Provided"}\" is not present in #{definition.keys.join(", ")}." if definition.keys.exclude? params[:request_verb]
+        # # Raise an exception if the verb is put or post and the body keys in definition are not all present as params keys, both params and definition[:body] can have nested objects
+        # raise EndpointValidationError, "The request body does not match the definition: in #{params[:request_verb]} requests all of the params must be present in definition. The body definition is #{definition[:body]}." if params[:request_verb] != "GET" && (body_mandatory_keys & params.keys) != body_mandatory_keys
+        # # Raise an exception if the verb is put or post and the body keys in definition are not all present as params keys, both params and definition[:body] can have nested objects
+        # raise EndpointValidationError, "The request query does not match the definition. The query definition is: #{definition[:query]}." if (query_mandatory_keys & params.keys) != query_mandatory_keys
+        # # Rais if the type of the param is not the same as the definition
+        # definition[:body].each do |k, v|
+        #     next if params[k].nil?
+        #     computed_type = get_type(params[k])
+        #     raise EndpointValidationError, "The type of the param #{k} is not the same as the definition. The definition is #{v[:type]} and the param is #{computed_type}." if v[:type] != computed_type
+        # end
     end
 
     private
 
+    def self.desc(key, definition)
+        self.definitions[key] = definition
+    end
+
     def get_type(type)
         case type
         when String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: model_driven_api
 version: !ruby/object:Gem::Version
-  version: 3.1.10
+  version: 3.1.11
 platform: ruby
 authors:
 - Gabriele Tassoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-18 00:00:00.000000000 Z
+date: 2024-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thecore_backend_commons