pragmarb / pragma Goto Github PK

class Update < Pragma::Operation::Update
  step :do_something!

  def do_something!(options)
    # { "my_attr" => ["before_value", "after_value"] }
    return unless options['result.updated_attributes'].key?('my_attr')

    # do something...
  end
end

class Show < Pragma::Operation::Show
  self['model.caching'] = true
end

# Responds and returns true
respond_with :not_found, entity: {}, headers: {}, decorator: MyDecorator

# Responds and returns false
respond_with! :not_found, entity: {}, headers: {}, decorator: MyDecorator

Pragma::Operation::Index.prepend (Module.new do
  def find_records
    relation = super
    if RolloutWrapper.active?(:auto_include_associations)
      relation = auto_include_associations(relation, params[:expand]) if params[:expand].present?
    end
    relation
  end

  private

  def auto_include_associations(relation, associations)
    to_include = associations.each_with_object({}) do |association, hash|
      hash = destruct_association(association, hash)
    end
    to_include = validate_associations(relation.model, to_include)
    Rails.logger.debug "Including: #{to_include}"
    relation.includes(to_include)
  end

  def destruct_association(association, hash = {})
    split = association.split('.')
    if split.length > 1
      value = split.shift
      hash[value] = {} unless hash[value]
      destruct_association(split.join('.'), hash[value])
    else
      value = split.shift
      hash[value] = {} unless hash[value]
    end
    hash
  end

  def validate_associations(model, associations)
    return associations if associations.empty?

    associations.each_with_object({}) do |(key, value), object|
      reflection = model.reflect_on_association(key.to_sym)
      if reflection.present?
        object[key] = validate_associations(reflection.klass, value)
      else
        {}
      end
    end
  end
end)

# app/models/post.rb
class Post < ApplicationRecord
  include Pragma::Metadata::Model
  # ...
end

# app/resources/api/v1/post/contract/base.rb
class API::V1::Post::Contract::Base < Pragma::Contract::Base
  include Pragma::Metadata::Contract
  # ...
end

# app/resources/api/v1/post/decorator/instance.rb
class API::V1::Post::Decorator::Instance < Pragma::Decorator::Base
  include Pragma::Metadata::Decorator
  # ...
end

# app/resources/api/v1/post.rb
Pragma::Resource.define :post do |config| # entire block is optional
  config.model_class = ::Post # optional, computed by default

  config.attributes do |attributes|
    attributes.define :title, :body do
      type :string
      validate :required?
    end

    attributes.define :author do
      default ->(options) { options['current_user'] }
      validate :required?
      visible false # not exposed in decorator
    end

    attributes.define :send_newsletter do
      type :boolean
      only :create # cannot be updated
      virtual # not saved to model
    end
  end

  # These would accept any callable object which receives `options`.
  # We would also have before_* and around_* hooks.
  config.hooks do |hooks|
    hooks.after_create API::V1::Post::Hook::NotifySubscribers
    hooks.after_update API::V1::Post::Hook::TouchLastUpdate
    hooks.after_save API::V1::Post::Hook::GenerateSummary
    hooks.after_destroy API::V1::Post::Hook::RemoveFromFeed
  end

  config.policy do |policy|
    policy.on :create? do |user, post|
      # ...
    end
  end
end

class Index < Pragma::Operation::Index
  self['ordering.columns'] = %i[created_at title]
  self['ordering.default_column'] = :created_at
  self['ordering.default_direction'] = :desc
end

class CustomCreate < Create
  step Pragma::Operation::Macro::Policy(action: :create?)
end

class Policy < Pragma::Policy::Base
  def custom_create?
    create?
  end
end

module API
  module V1
    module Article
      module Operation
        class Index < Pragma::Operation::Index
          self['schema.default'] = Dry::Validation.Schema do
            optional(:user_id).maybe(:int?)
          end
        end
      end
    end
  end
end

step Model(invoice_id: :id) # WHERE invoice_id = params[:invoice_id] AND id = params[:id]
step Model(:id) # WHERE id = params[:id]
step Model(:slug, :id) # WHERE slug = params[:id] OR id = params[:id]

class Create < Pragma::Operation::Create
  class CustomCreate < Create
    step Pragma::Operation::Macro::Classes()
  end
end

self['model.class'] = '???' # not sure how to do this one
self['policy.default.class'] = Policy
self['policy.default.scope.class'] = Policy::Scope
self['decorator.instance.class'] = Decorator::Instance
self['decorator.collection.class'] = Decorator::Collection
self['contract.default.class'] = Contract::Create::CustomCreate

class Index < Pragma::Operation::Index
  self['filters'] = [
    Pragma::Operation::Filter::Like.new(param: :by_name, column: :name),
    Pragma::Operation::Filter::Ilike.new(param: :by_iname, column: :name),
    Pragma::Operation::Filter::Eq.new(param: :by_country_code, column: :country_code),
  ]
end

result = Api::V2::User::Operation::Show.call('id' => 1)
result['result.last_step'] # => "model.find_by"
result['result.failing_step'] # => "policy.default"

steps = Api::V2::User::Operation::Show.skills['pipetree'].instance_variable_get('@index').keys
steps[steps.index(result['result.last_step']) + 1]

options['result.response'] = Pragma::Operation::Response::NotFound
  .new
  .decorate_with(Pragma::Decorator::Error)

class Pragma::Operation::Base < Trailblazer::Operation
  def call(*)
    result = super
    result['result.response'] = '...'
  end
end