praxis 2.0.pre.10 → 2.0.pre.11

data/tasks/thor/templates/generator/example_app/app/v1/controllers/users.rb

@@ -4,8 +4,8 @@ module V1
   module Controllers
     class Users
       include Praxis::Controller
-      include Praxis::Extensions::Rendering
-      
+      include Concerns::ControllerBase
+
       implements V1::Endpoints::Users
 
       def index

data/tasks/thor/templates/generator/example_app/app/v1/resources/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module V1
+  module Resources
+    class Base < Praxis::Mapper::Resource
+      # Base for all V1 resources.
+      # Resources withing a single version should have resource mappings separate from other versions
+      # and the Mapper::Resource will appropriately maintain different model_maps for each Base classes
+    end
+  end
+end

data/tasks/thor/templates/generator/example_app/app/v1/resources/user.rb

@@ -2,42 +2,21 @@
 
 module V1
   module Resources
-    class User < Praxis::Mapper::Resource
+    class User < Base
       model ::User
 
-      # Mappings for the allowed filterd
+      # Mappings for the allowed filters
       filters_mapping(
-        'email': 'email',
-        'first_name': 'first_name',        
-        # Complex (convoluted?) mapping of state, just to show how we can modify and adapt the values/fields/operators
-        'state': lambda do |spec|
-          case spec[:value].to_s
-          when 'pending' # Pending users do not have a uuid
-            { name: :uuid, value: nil, op: spec[:op] }
-          when 'active' # Active users do not have a uuid (so "flip" the original equality condition)
-            opposite_op = spec[:op] == '=' ? '!=' : '='
-            { name: :uuid, value: nil, op: opposite_op }
-          else
-            raise "Cannot filter users by state #{spec[:value]}"
-          end
-        end,
+        'uuid': 'uuid',
+        'first_name': 'first_name',
+        'last_name': 'last_name',
+        'email': 'email'
       )
 
-      # Example of a property that depends on a differently named DB field
-      property :uid, dependencies: %i[id]
       # To compute the full_name (method below) we need to load first and last names from the DB
       property :full_name, dependencies: %i[first_name last_name]
 
-      def uid
-        id # underlying id field of the model
-      end
-
-      # Computed attribute: if uuid nil, user in in a pending stat, else active
-      def state 
-        self.uuid.nil? ? 'pending' : 'active'
-      end
-
-      # Computed attribute the combines first and last
+      # Computed attribute that combines first and last
       def full_name
         [first_name, last_name].join(' ')
       end

data/tasks/thor/templates/generator/example_app/config.ru

@@ -8,10 +8,9 @@ Bundler.require(:default, ENV['RACK_ENV'])
 # API field selection (a la GraphQL) - for querying and rendering
 # API filtering extensions (to add "where clauses") in listings
 # Views and partial rendering (for ActiveRecord models)
-
 require 'praxis/plugins/mapper_plugin'
 require 'praxis/mapper/active_model_compat'
-require 'praxis/extensions/field_selection'
+# Want to take advantage of the pagination and sorting extensions as well
 require 'praxis/plugins/pagination_plugin'
 
 # Start the sqlite DB

data/tasks/thor/templates/generator/example_app/config/environment.rb

@@ -3,7 +3,7 @@ Praxis::Application.configure do |application|
 
   # Configure the Mapper plugin (if we want to use all the filtering/field_selection extensions)
   application.bootloader.use Praxis::Plugins::MapperPlugin
-  # Cconfigure the Pagination plugin (if we want to use all the pagination/ordering extensions)
+  # Configure the Pagination plugin (if we want to use all the pagination/ordering extensions)
   application.bootloader.use Praxis::Plugins::PaginationPlugin, {
     # max_items: 500,  # Unlimited by default,
     # default_page_size: 100,
@@ -33,6 +33,7 @@ Praxis::Application.configure do |application|
   #     map :models, 'models/**/*'
   #     map :responses, '**/responses/**/*'
   #     map :exceptions, '**/exceptions/**/*'
+  #     map :concerns, '**/concerns/**/*'
   #     map :resources, '**/resources/**/*'
   #     map :controllers, '**/controllers/**/*'
   #   end

data/tasks/thor/templates/generator/example_app/db/migrate/20201010101010_create_users_table.rb

@@ -3,9 +3,10 @@
 class CreateUsersTable < ActiveRecord::Migration[5.2]
   def change
     create_table :users do |table|
-      table.column :uuid, :integer
-      table.column :first_name, :string
+      table.column :uuid, :string, null: false
+      table.column :first_name, :string, null: false
       table.column :last_name, :string
+      table.column :email, :string
     end
   end
 end

data/tasks/thor/templates/generator/example_app/db/seeds.rb

@@ -0,0 +1,6 @@
+
+require_relative '../spec/helpers/database_helper'
+# Invoke the encapsulated seed class...
+DatabaseHelper.seed!
+
+# Add more seeds here..

data/tasks/thor/templates/generator/example_app/design/v1/endpoints/users.rb

@@ -4,7 +4,6 @@ module V1
   module Endpoints
     class Users
       include Praxis::EndpointDefinition
-      # include AuthenticatedEndpoint
 
       media_type MediaTypes::User
       version '1'
@@ -18,15 +17,16 @@ module V1
           attribute :fields, Praxis::Types::FieldSelector.for(MediaTypes::User),
                     description: 'Fields with which to render the result.'
           attribute :filters, Praxis::Types::FilteringParams.for(MediaTypes::User) do
-            filter 'state', using: ['=', '!=']
+            filter 'uuid', using: ['=', '!=']
             filter 'first_name', using: ['=', '!='], fuzzy: true
             filter 'last_name', using: ['=', '!='], fuzzy: true
+            filter 'email', using: ['=', '!=']
           end
           attribute :pagination, Praxis::Types::PaginationParams.for(MediaTypes::User) do
-            by_fields :uid, :first_name, :last_name
+            by_fields :uuid, :first_name, :last_name
           end
           attribute :order, Praxis::Extensions::Pagination::OrderingParams.for(MediaTypes::User) do
-            by_fields :uid, :last_name, :first_name
+            by_fields :uuid, :last_name, :first_name
           end          
         end
         response :ok, media_type: Praxis::Collection.of(MediaTypes::User)

data/tasks/thor/templates/generator/example_app/design/v1/media_types/user.rb

@@ -9,16 +9,11 @@ module V1
       description 'A user in the system'
 
       attributes do
-        attribute :uid, String
+        attribute :id, Integer
         attribute :uuid, String
         attribute :email, String
         attribute :first_name, String
         attribute :last_name, String
-        attribute :state, String, values: %i[pending active]
-      end
-
-      default_fieldset do
-        attribute :uid
       end
     end
   end

data/tasks/thor/templates/generator/example_app/spec/helpers/database_helper.rb

@@ -5,8 +5,9 @@ class DatabaseHelper
   # This does the job for an example seeder
   def self.seed!
     user_data = [
-      {id: 11, first_name: 'Peter', last_name: 'Praxis', uuid: 'deadbeef'},
-      {id: 12, first_name: 'Alice', last_name: 'Trellis', uuid: 'beefdead'}
+      {id: 11, first_name: 'Peter', last_name: 'Praxis', uuid: 'deadbeef', email: 'peter@pan.com'},
+      {id: 12, first_name: 'Alice', last_name: 'Trellis', uuid: 'beefdead', email: 'alice@wonderland.com'},
+      {id: 13, first_name: 'Wellington', last_name: 'Lofty', uuid: 'beefbeef', email: 'well@lofty.com'},
     ]
     (100..199).each do |i|
       user_data.push id: i, first_name: "User-#{i}", last_name: "Last-#{i}", uuid: SecureRandom.hex(16).to_s
@@ -14,5 +15,6 @@ class DatabaseHelper
     user_data.each_with_index do |data, i|
       ::User.create(**data)
     end
+    puts "Database seeded."
   end
 end

data/tasks/thor/templates/generator/example_app/spec/spec_helper.rb

@@ -11,10 +11,10 @@ rescue => e
 end
 
 # Migrate and seed the DB (only an empty in-memory DB)
-require_relative 'helpers/database_helper'
+
 ActiveRecord::Migration.verbose = false # ?? does not seem to work like this
 ActiveRecord::Tasks::DatabaseTasks.migrate
-DatabaseHelper.seed!
+require_relative '../db/seeds.rb'
 
 RSpec.configure do |config|
   config.include Rack::Test::Methods

data/tasks/thor/templates/generator/example_app/spec/v1/controllers/users_spec.rb

@@ -13,7 +13,7 @@ describe V1::Controllers::Users do
 
   context 'index' do
     let(:filters_q) { '' }
-    let(:fields_q) { 'uid,uuid' }
+    let(:fields_q) { 'id' }
     let(:query_string) do
       "filters=#{CGI.escape(filters_q)}&fields=#{CGI.escape(fields_q)}"
     end
@@ -30,7 +30,7 @@ describe V1::Controllers::Users do
       it 'returns only peter' do
         expect(parsed_body.size).to eq(1)
         # Peter has id 11 from our seeds
-        expect(parsed_body.map{|u| u[:uid]}).to eq(['11'])
+        expect(parsed_body.map{|u| u[:id]}).to eq([11])
       end
     end
   end

data/tasks/thor/templates/generator/scaffold/design/endpoints/collection.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module <%= version_module %>
+  module Endpoints
+    class <%= plural_class %>
+      include Praxis::EndpointDefinition
+
+      media_type MediaTypes::<%= singular_class %>
+      version '<%= version %>'
+
+      description 'Praxis-generated endpoint for managing <%= plural_class %>'
+
+      <%- if action_enabled?(:index) -%>
+      action :index do
+        description 'List <%= plural_class %>'
+        routing { get '' }
+        params do
+          attribute :fields, Praxis::Types::FieldSelector.for(MediaTypes::<%= singular_class %>),
+                    description: 'Fields with which to render the result.'
+<%- if !pagination_enabled? -%>
+=begin
+          # You can use pagination/ordering by enabling the PaginationPlugin, and uncommenting these lines
+<%- end -%>
+          attribute :pagination, Praxis::Types::PaginationParams.for(MediaTypes::<%= singular_class %>)
+          attribute :order, Praxis::Extensions::Pagination::OrderingParams.for(MediaTypes::<%= singular_class %>)
+<%- if !pagination_enabled? -%>
+=end
+<%- end -%>
+          # # Filter by attributes. Add an allowed filter per line, with the allowed operators to use
+          # # Also, remember to add a mapping for each in `filters_mapping` method of Resources::<%= singular_class %> class
+          # attribute :filters, Praxis::Types::FilteringParams.for(MediaTypes::<%= singular_class %>) do
+          #    filter 'first_name', using: ['=', '!='], fuzzy: true
+          # end
+        end
+        response :ok, media_type: Praxis::Collection.of(MediaTypes::<%= singular_class %>)
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:index) -%>
+      action :show do
+        description 'Retrieve details for a specific <%= singular_class %>'
+        routing { get '/:id' }
+        params do
+          attribute :id, required: true
+          attribute :fields, Praxis::Types::FieldSelector.for(MediaTypes::<%= singular_class %>),
+                    description: 'Fields with which to render the result.'
+        end
+        response :ok
+        response :not_found
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:create) -%>
+      action :create do
+        description 'Create a new <%= singular_class %>'
+        routing { post '' }
+        payload reference: MediaTypes::<%= singular_class %> do
+          # List the attributes you accept from the one existing in the <%= singular_class %> Mediatype
+          # and/or fully define any other ones you allow at creation time
+          # attribute :name
+        end
+        response :created
+        response :bad_request
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:update) -%>
+      action :update do
+        description 'Update one or more attributes of an existing <%= singular_class %>'
+        routing { patch '/:id' }
+        params do
+          attribute :id, required: true
+        end
+        payload reference: MediaTypes::<%= singular_class %> do
+          # List the attributes you accept from the one existing in the <%= singular_class %> Mediatype
+          # and/or fully define any other ones you allow to change
+          # attribute :name
+        end
+        response :no_content
+        response :bad_request
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:update) -%>
+      action :delete do
+        description 'Deletes a <%= singular_class %>'
+        routing { delete '/:id' }
+        params do
+          attribute :id, required: true
+        end
+        response :no_content
+        response :not_found
+      end
+      <%- end -%>
+    end
+  end
+end
+

data/tasks/thor/templates/generator/scaffold/design/media_types/item.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module <%= version_module %>
+  module MediaTypes
+    class <%= singular_class %> < Praxis::MediaType
+      identifier 'application/json'
+
+      domain_model '<%= version_module %>::Resources::<%= singular_class %>'
+      description 'Structural definition of a <%= singular_class %>'
+
+      attributes do
+        attribute :id, Integer, description: '<%= singular_class %> identifier'
+        # <INSERT MORE ATTRIBUTES HERE>
+      end
+    end
+  end
+end
+

data/tasks/thor/templates/generator/scaffold/implementation/controllers/collection.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module <%= version_module %>
+  module Controllers
+    class <%= plural_class %>
+      include Praxis::Controller
+
+      implements Endpoints::<%= plural_class %>
+
+      <%- if action_enabled?(:index) -%>
+      # Retrieve all <%= plural_class %> with the right necessary associations
+      # and render them appropriately with the requested field selection
+      def index
+        objects = build_query(model_class).all
+        display(objects)
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:show) -%>
+      # Retrieve a single <%= singular_class %> with the right necessary associations
+      # and render them appropriately with the requested field selection
+      def show(id:, **_args)
+        model = build_query(model_class.where(id: id)).first
+        return Praxis::Responses::NotFound.new if model.nil?
+
+        display(model)
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:create) -%>
+      # Creates a new <%= singular_class %>
+      def create
+        # A good pattern is to call the same name method on the corresponding resource, 
+        # passing the incoming payload, or massaging it first
+        created_resource = Resources::<%= singular_class%>.create(request.payload)
+
+        # Respond with a created if it successfully finished
+        Praxis::Responses::Created.new(location: created_resource.href)
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:update) -%>
+      # Updates some of the information of a <%= singular_class %>
+      def update(id:)
+        # A good pattern is to call the same name method on the corresponding resource, 
+        # passing the incoming id and payload (or massaging it first)
+        updated_resource = Resources::<%= singular_class %>.update(
+          id: id,
+          payload: request.payload,
+        )
+        return Praxis::Responses::NotFound.new unless updated_resource
+
+        Praxis::Responses::NoContent.new
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:delete) -%>
+      # Deletes an existing <%= singular_class %>
+      def delete(id:)
+        # A good pattern is to call the same name method on the corresponding resource,
+        # maybe passing the already loaded model
+        deleted_resource = Resources::<%= singular_class %>.delete(
+          id: id
+        )
+        return Praxis::Responses::NotFound.new unless deleted_resource
+
+        Praxis::Responses::NoContent.new
+      end
+      <%- end -%>
+
+      # Use the model class as the base query but you might want to change that
+      def model_class
+        ::<%= singular_class %> #Change it to the appropriate DB model class
+      end
+    end
+  end
+end

data/tasks/thor/templates/generator/scaffold/implementation/resources/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module <%= version_module %>
+  module Resources
+    class Base < Praxis::Mapper::Resource
+      # Base for all <%= version_module %> resources.
+      # Resources withing a single version should have resource mappings separate from other versions
+      # and the Mapper::Resource will appropriately maintain different model_maps for each Base classes
+    end
+  end
+end

data/tasks/thor/templates/generator/scaffold/implementation/resources/item.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module <%= version_module %>
+  module Resources
+    class <%= singular_class %> < Base
+      model ::<%= singular_class %> # Change it if it maps to a different DB model class
+
+      # Define the name mapping from API filter params, to model attribute/associations
+      # when they aren't 1:1
+      # filters_mapping(
+      #   'name': 'name',
+      #   'label': 'association.label_name'
+      # )
+
+      # Add dependencies for resource attributes to other attributes and/or model associations
+      # property :href, dependencies: %i[id]
+
+      <%- if action_enabled?(:create) -%>
+      def self.create(payload)
+        # Assuming the API field names directly map the the model attributes. Massage if appropriate.
+        self.new(model.create(*payload.to_h))
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:update) -%>
+      def self.update(id:, payload:)
+        record = model.find_by(id: id)
+        return nil unless record
+        # Assuming the API field names directly map the the model attributes. Massage if appropriate.
+        record.update(*payload.to_h)
+        self.new(record)
+      end
+      <%- end -%>
+
+      <%- if action_enabled?(:delete) -%>
+      def self.delete(id:)
+        record = model.find_by(id: id)
+        return nil unless record
+        record.destroy
+        self.new(record)
+      end
+      <%- end -%>  
+    end
+  end
+end