building a class method combining two classes with same parent class

Two classes are related via a same parent

class Promoitem 
  belongs_to :shop
  belongs_to :article, optional: true

class Cartitem 
  belongs_to :article
  belongs_to :cart

class Cart 
  belongs_to :shop

class Article
  has_many   :cartitems
  has_many   :promoitems

An existing controller method executes logic as follows:

valid_promo = Promoitem.where('shop_id = ? AND date_start <= ? AND date_end >= ? AND article_id = ?', @shop.id, Date.today, Date.today, cartitem.article_id ).first
if valid_promo
  api_price = valid_promo.price_promo
else
  api_price = cartitem.article.sell_price
end

but that makes the controller fat and this logic could reside in the cartitem model definition.
the goal is to write efficient model methods.

class Cartitem 
# scope is bad
  scope :price_promo, lambda { joins(:promoitems).where("date_start <= ? AND date_end >= ? AND article_id = ?", Date.today, Date.today, self.article_id) }

def valid_promo
  self.promoitems.price_promo
end

def api_price
  if self.valid_promo
    self.promoitems.price_promo
  else
    self.article.sell_price
  end 
end

The scope definition is wrong, as the relationship is via the article class. Thus each class could have

  has_many :promoitems, through: :articles 
  has_many :cartitems, through: :articles

But how does that translate into a proper scope that is effective at querying as the controller method - or is there a better way to do this?

Your relationship is very awkward and would greatly benefit from some restructuring because this statement "...as the relationship is via the article class." is not technically true. The relationship is actually via the "article" and the "cart => shop" making it very awkward to query directly.

That being said under your current circumstances you should be able to use the following:

class Cartitem < ApplicationRecord 
  scope :with_promo_pricing, -> { 
    promo_table = PromoItem.arel_table
    promo_join = Arel::Nodes::OuterJoin.new(promo_table,
                   promo_table
                     .create_on(
                         promo_table[:article_id].eq(arel_table[:article_id])
                         .and(promo_table[:shop_id].eq(Cart.arel_table[:shop_id])
                 ))
    joins(:cart, :article) 
      .joins(promo_join)
      .select(arel_table[Arel.star],
              Arel::Nodes::NamedFunction.new('ISNULL',
                [promo_table[:price_promo],
                Article.arel_table[:sell_price]]
              ).as('final_price')
            )
      .where(promo_items: {start_date: ..Date.today, end_date: Date.today..}) 
  } 
  def api_price
    attributes['final_price'] || self.class.where(id: self.id).with_promo_pricing.final_price
  end 
end 

This should produce the following SQL

SELECT 
  cartitems.*,
  ISNULL(promoitems.price_promo,articles.sell_price) AS final_price
FROM 
  cartitems 
  INNER JOIN carts ON carts.id = cartitems.cart_id 
  INNER JOIN articles ON articles.id = cartitems.article_id
  LEFT OUTER JOIN promoitems ON promoitems.article_id = cartitems.article_id
    AND carts.shop_id = promoitems.shop_id
WHERE 
  promoitems.start_date <= '2023-03-07' AND 
  promoitems.end_date >= '2023-03-07'

You could also use this with a Cart which I assume has to be the intent e.g.

@cart.cartitems.with_promo_pricing