lesli 5.0.23 → 5.1.0

data/lib/generators/lesli/model/templates/model.rb.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module <%= engine_namespace %>
+    class <%= resource_class_name %> < ApplicationRecord
+        belongs_to :account
+
+        # Optional user relations
+        # belongs_to :owner, class_name: "Lesli::User"
+        # belongs_to :user, class_name: "Lesli::User"
+
+        # Optional item concerns
+        # include Lesli::Item::Tasks
+        # include Lesli::Item::Activities
+        # include Lesli::Item::Discussions
+    end
+end

data/lib/generators/lesli/scaffold/scaffold_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../base_generator"
+
+module Lesli
+    module Generators
+        # Main Lesli scaffold generator.
+        #
+        # This generator delegates work to the specialized generators.
+        class ScaffoldGenerator < BaseGenerator
+            argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+            def invoke_model_generator
+                invoke "lesli:model", [name, *attributes]
+            end
+
+            # Invokes the custom Lesli controller generator.
+            def invoke_controller_generator
+                invoke "lesli:controller", [name, *attributes]
+            end
+
+            # Invokes the custom Lesli service generator.
+            def invoke_service_generator
+                invoke "lesli:service", [name, *attributes]
+            end
+
+            def invoke_views_generator
+                invoke "lesli:views", [name, *attributes]
+            end
+
+            def invoke_migration_generator
+                invoke "active_record:migration", [migration_name, *attributes]
+            end
+
+            def invoke_route_generator
+                invoke "resource_route", [resource_collection_name]
+            end
+
+            private
+
+            def migration_name
+                "create_#{engine_name}_#{resource_collection_name}"
+            end
+        end
+    end
+end

data/lib/generators/lesli/service/service_generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../base_generator"
+
+module Lesli
+    module Generators
+        # Generates a Lesli-style service object inside the current engine.
+        class ServiceGenerator < BaseGenerator
+            argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+            source_root File.expand_path("templates", __dir__)
+
+            # Creates the service file from the template.
+            def create_service_file
+                template "service.rb.tt", service_file_path
+            end
+
+            private
+
+            # Returns the service directory inside the engine namespace.
+            #
+            # Example:
+            #   app/services/lesli_support
+            #   app/services/my_engine
+            #   app/services/store
+            def service_directory
+                File.join(ENGINE_ROOT, "app/services", engine_name)
+            end
+
+            # Returns the final service file path.
+            #
+            # Example:
+            #   app/services/lesli_support/ticket_service.rb
+            def service_file_path
+                File.join(service_directory, "#{resource_name}_service.rb")
+            end
+        end
+    end
+end

data/lib/generators/lesli/service/templates/service.rb.tt

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module <%= engine_namespace %>
+  class <%= service_class_name %> < Lesli::ApplicationLesliService
+
+    def find(id: nil, uid: nil)
+      scope = current_user.account.<%= engine_domain_name %>.<%= resource_collection_name %>
+
+      # Build the search hash using only present values.
+      params = { id: id, uid: uid }.compact
+
+      # Only perform the lookup when at least one filter is present.
+      super(scope.find_by(params)) if params.any?
+    end
+
+    def index
+      current_user.account.<%= engine_domain_name %>.<%= resource_collection_name %>.order(id: :desc)
+    end
+
+    def create(<%= params_method_name %>)
+      <%= resource_name %> = current_user.account.<%= engine_domain_name %>.<%= resource_collection_name %>.new(<%= params_method_name %>)
+
+      if <%= resource_name %>.save
+        self.resource = <%= resource_name %>
+      else
+        self.error(<%= resource_name %>.errors.full_messages.to_sentence)
+      end
+
+      self
+    end
+
+    def show
+      self.resource
+    end
+
+    def update(params)
+      self.resource.update(params)
+    end
+
+    def destroy
+      self.resource.destroy
+    end
+  end
+end

data/lib/generators/lesli/views/templates/_form.html.erb.tt

@@ -0,0 +1,22 @@
+<%%= form_with(model: <%= resource_instance %>, builder: LesliView::Forms::Builder) do |form| %>
+    <%%= form.fieldset do %>
+        <% form_attributes.each do |attribute| -%>
+            <% if attribute == "description" -%>
+                <%%= form.field_control_textarea(:<%= attribute %>, label: false) %>
+            <% else -%>
+                <%%= form.field_control(:<%= attribute %>) %>
+            <% end -%>
+        <% end -%>
+
+        <% if select_attributes.any? -%>
+            <div class="columns">
+                <% select_attributes.each do |attribute| -%>
+                    <div class="column">
+                        <%%= form.field_control_select(:<%= attribute %>, []) %>
+                    </div>
+                <% end -%>
+            </div>
+        <% end -%>
+        <%%= form.field_control_submit %>
+    <%% end %>
+<%% end %>

data/lib/generators/lesli/views/templates/index.html.erb.tt

@@ -0,0 +1,17 @@
+<%% columns = [
+    {
+        label: "ID",
+        field: "id"
+    }
+] %>
+
+<%%= render(LesliView::Layout::Container.new("<%= engine_domain_name %> - <%= resource_collection_name %>")) do %>
+    <%%= render(LesliView::Components::Header.new("<%= resource_collection_name.humanize %>", new_path: new_<%= resource_name %>_path)) %>
+    <%%= render(LesliView::Components::Toolbar.new) %>
+
+    <%%= render(LesliView::Elements::Table.new(
+        columns: columns,
+        records: <%= resource_collection_instance %>.dig(:records),
+        link: -> (<%= resource_name %>) { <%= resource_name %>_path(<%= resource_name %>.id) }
+    )) %>
+<%% end %>

data/lib/generators/lesli/views/templates/new.html.erb.tt

@@ -0,0 +1,4 @@
+<%%= render(LesliView::Layout::Container.new("new-<%= resource_name %>")) do %>
+    <%%= render(LesliView::Components::Header.new("New <%= resource_class_name %>")) %>
+    <%%= render("form") %>
+<%% end %>

data/lib/generators/lesli/views/templates/show.html.erb.tt

@@ -0,0 +1,22 @@
+<%%= render(LesliView::Layout::Container.new("<%= engine_domain_name %>-<%= resource_collection_name %>")) do %>
+
+    <%%= render(LesliView::Components::Header.new("<%= resource_class_name %>")) %>
+
+    <%%= render(LesliView::Components::Tabs.new(active_tab: "<%= resource_name %>-information")) do |tabs| %>
+        <%% tabs.with_tab(id:"<%= resource_name %>-information", title:"Information", icon:"info") do %>
+            <%%= render("form") %>
+        <%% end %>
+
+        <%% tabs.with_tab(id:"<%= resource_name %>-discussions", title:"Discussions", icon:"forum") do %>
+            <%%= render(LesliView::Items::Discussions.new(<%= resource_instance %>)) %>
+        <%% end %>
+
+        <%% tabs.with_tab(id:"<%= resource_name %>-tasks", title:"Tasks", icon:"checklist") do %>
+            <%%= render(LesliView::Item::Tasks.new(<%= resource_instance %>)) %>
+        <%% end %>
+
+        <%% tabs.with_tab(id:"<%= resource_name %>-activities", title:"Activities", icon:"search_activity") do %>
+            <%%= render(LesliView::Items::Activities.new(<%= resource_instance %>)) %>
+        <%% end %>
+    <%% end %>
+<%% end %>

data/lib/generators/lesli/views/views_generator.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../base_generator"
+
+module Lesli
+    module Generators
+        # Generates Lesli-style views for a resource inside the current engine.
+        #
+        # Example:
+        #   rails generate lesli:views tickets subject:string description:text owner_id:integer
+        #
+        # Result:
+        #   app/views/lesli_support/tickets/
+        #     _form.html.erb
+        #     index.html.erb
+        #     show.html.erb
+        #     new.html.erb
+        #     edit.html.erb
+        class ViewsGenerator < BaseGenerator
+            argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+            source_root File.expand_path("templates", __dir__)
+
+            # Creates the views directory if it does not exist.
+            def create_views_directory
+                empty_directory views_directory
+            end
+
+            # Generates the shared form partial.
+            def create_form_partial
+                template "_form.html.erb.tt", File.join(views_directory, "_form.html.erb")
+            end
+
+            # Generates the index view.
+            def create_index_view
+                template "index.html.erb.tt", File.join(views_directory, "index.html.erb")
+            end
+
+            # Generates the show view.
+            def create_show_view
+                template "show.html.erb.tt", File.join(views_directory, "show.html.erb")
+            end
+
+            # Generates the new view.
+            def create_new_view
+                template "new.html.erb.tt", File.join(views_directory, "new.html.erb")
+            end
+
+            private
+
+            # Returns the target views directory for the current resource.
+            #
+            # Example:
+            #   app/views/lesli_support/tickets
+            def views_directory
+                File.join(ENGINE_ROOT, "app/views", engine_name, resource_collection_name)
+            end
+
+            # Returns only scalar-like attributes that can be rendered
+            # as regular text inputs by default.
+            def form_attributes
+                permitted_attributes.reject do |attribute|
+                    attribute.end_with?("_id") || attribute == "id"
+                end
+            end
+
+            # Returns attributes that look like foreign keys.
+            #
+            # Example:
+            #   owner_id, category_id, priority_id
+            #
+            # These are rendered as generic select controls.
+            def select_attributes
+                permitted_attributes.select { |attribute| attribute.end_with?("_id") }
+            end
+
+            # Returns the default columns used for the index table.
+            #
+            # We prefer to include uid first when it exists.
+            def index_columns
+                columns = []
+
+                if permitted_attributes.include?("uid")
+                    columns << { label: "ID", field: "uid" }
+                end
+
+                form_attributes.each do |attribute|
+                    columns << {
+                        label: attribute.humanize,
+                        field: attribute
+                    }
+                end
+
+                select_attributes.each do |attribute|
+                    columns << {
+                        label: attribute.delete_suffix("_id").humanize,
+                        field: attribute
+                    }
+                end
+
+                columns
+            end
+        end
+    end
+end

data/lib/lesli/engine.rb

@@ -36,7 +36,7 @@ require "kaminari"
 
 # · Tools used to build the Lesli Framework
 require "L2"
-#require "useragent"
+require "termline"
 require "acts_as_paranoid"
 
 # The hole Lesli ecosystem depends on current_user, so we
@@ -48,26 +48,14 @@ require "lesli_view"
 require "lesli_assets"
 require "lesli_system"
 
-require "importmap-rails"
 require "turbo-rails"
 
 module Lesli
     class Engine < ::Rails::Engine
         isolate_namespace Lesli
 
-        initializer "lesli.importmap", before: "importmap" do |app|
-            app.config.importmap.paths << Engine.root.join("config/importmap.rb")
-        end
-
         initializer :lesli do |app|
 
-
-            # Lesli standard engine configuration
-
-            
-            # register assets manifest
-            config.assets.precompile += %w[lesli_manifest.js]
-
             # register engine migrations path
             unless app.root.to_s.match root.to_s
                 config.paths["db/migrate"].expanded.each do |expanded_path|
@@ -75,20 +63,10 @@ module Lesli
                 end
             end
 
-
-            # Lesli Framework configuration
-
-
             # Default languages
             config.i18n.default_locale = :en
             config.i18n.available_locales = [:en]
 
-            # Force to not use digest, 
-            # if this is not false Rails will fingerprint the assets by default 
-            # and precompile will be needed, so, donot digest if not production
-            #config.assets.digest = false unless Rails.env.production?
-
-
             # Lesli Framework Mailer configuration
 
 

data/lib/lesli/router.rb

@@ -31,58 +31,57 @@ Building a better future, one line of code at a time.
 =end
 
 # ·
-module Lesli 
-    module Router 
-
-        def self.login path=""
-
-            # Load dedicated mounting routes for devise from the LesliShield engine
-            LesliShield::Router.mount_login_at(path) if defined?(LesliShield);
-
-            # Load generic yet standard routes if LesliShield is not installed
-            if !defined?(LesliShield) && defined?(Devise)
-                Rails.application.routes.draw do
-                    devise_for(:users, class_name: "Lesli::User", module: :devise) 
-                end
+module Lesli
+    module Router
+        def self.login(router, path = "")
+            # Prefer LesliShield’s dedicated routes if installed
+            if defined?(LesliShield)
+                # Make LesliShield::Router accept router too (recommended)
+                LesliShield::Router.mount_login_at(router, path)
+            elsif defined?(Devise)
+                router.devise_for :users, class_name: "Lesli::User", module: :devise
             end
         end
 
-        def self.mount
-            self.login
-            Rails.application.routes.draw do
-                root to: "lesli/abouts#welcome", as: :welcome
-                mount Lesli::Engine => "/lesli" if defined?(Lesli)
-                mount LesliBell::Engine => "/bell" if defined?(LesliBell)
-                mount LesliAdmin::Engine => "/admin" if defined?(LesliAdmin)
-                mount LesliAudit::Engine => "/audit" if defined?(LesliAudit)
-                mount LesliBabel::Engine => "/babel" if defined?(LesliBabel)
-                mount LesliMailer::Engine => "/mailer" if defined?(LesliMailer)
-                mount LesliShield::Engine => "/shield" if defined?(LesliShield)
-                mount LesliPapers::Engine => "/papers" if defined?(LesliPapers)
-                mount LesliSupport::Engine => "/support" if defined?(LesliSupport)
-                mount LesliSecurity::Engine => "/security" if defined?(LesliSecurity)
-                mount LesliCalendar::Engine => "/calendar" if defined?(LesliCalendar)
-                mount LesliContacts::Engine => "/contacts" if defined?(LesliContacts)
-                mount LesliDashboard::Engine => "/dashboard" if defined?(LesliDashboard)
-            end
+        def self.mount(router, path = "")
+            login(router, path)
+
+            router.root to: "lesli/abouts#welcome", as: :welcome
+
+            router.mount Lesli::Engine => "/lesli" if defined?(Lesli)
+            router.mount LesliBell::Engine => "/bell" if defined?(LesliBell)
+            router.mount LesliAdmin::Engine => "/admin" if defined?(LesliAdmin)
+            router.mount LesliAudit::Engine => "/audit" if defined?(LesliAudit)
+            router.mount LesliBabel::Engine => "/babel" if defined?(LesliBabel)
+            router.mount LesliMailer::Engine => "/mailer" if defined?(LesliMailer)
+            router.mount LesliShield::Engine => "/shield" if defined?(LesliShield)
+            router.mount LesliPapers::Engine => "/papers" if defined?(LesliPapers)
+            router.mount LesliSupport::Engine => "/support" if defined?(LesliSupport)
+            router.mount LesliSecurity::Engine => "/security" if defined?(LesliSecurity)
+            router.mount LesliCalendar::Engine => "/calendar" if defined?(LesliCalendar)
+            router.mount LesliContacts::Engine => "/contacts" if defined?(LesliContacts)
+            router.mount LesliDashboard::Engine => "/dashboard" if defined?(LesliDashboard)
         end
 
-        def self.mount_routes_for lesli_engine
-            lesli_engine::Engine.routes.draw do
+        # Shared default routes for any Lesli engine
+        def self.mount_lesli_engine_routes(router)
+            router.root to: "dashboards#show"
+
+            # Load dashboard resources
+            router.resource :dashboard, only: %i[show edit]
 
-                # Dashboard alias
-                root to: "dashboards#show"
+            # Load Lesli items
+            router.namespace :item do
 
-                # Dashboard management
-                resource :dashboard, only: [:show, :edit]
+                # Load item tasks
+                router.resources :tasks, only: %i[index update create]
 
-                # 
-                get "up" => "/rails/health#show"
+                # Load item discussions
+                router.resources :discussions, only: %i[index update create]
             end
-        end
 
-        def self.mount_dashboard_for lesli_engine
-            self.mount_routes_for(lesli_engine)
+            # Optional: health check inside engine scope (pick a consistent path)
+            router.get "up", to: "/rails/health#show"
         end
-    end 
+    end
 end

data/lib/lesli/version.rb

@@ -1,4 +1,4 @@
 module Lesli
-  VERSION = "5.0.23"
-  BUILD = "1771707881"
+  VERSION = "5.1.0"
+  BUILD = "1774678451"
 end

data/lib/migrate/common.rb

@@ -45,7 +45,7 @@ module MigrationHelpers
             engine = infer_engine_from_namespace
 
             resource = resources.to_s.singularize
-            table_name = "#{resource}_#{item}".to_sym
+            table_name = "#{resource}_item_#{item}".to_sym
             foreign_key = resource.sub("#{engine}_","")
 
             return [table_name, foreign_key]

data/lib/migrate/items/activity_structure.rb

@@ -33,10 +33,10 @@ Building a better future, one line of code at a time.
 module MigrationHelpers
     module Items
         module ActivityStructure
-            def create_table_lesli_item_activities_10(resources)
+            def create_table_lesli_item_activities_10(engine)
+
+                table_name, foreign_key = table_name_for_item(engine, :activities)
 
-                table_name, foreign_key = table_name_for_item(resources, :activities)
-    
                 create_table table_name do |t|
 
                     # Contenido
@@ -51,11 +51,17 @@ module MigrationHelpers
                     # Metadatos opcionales (JSON)
                     t.json :metadata, default: {}
 
+                    # Polymorphic target
+                    t.string  :subject_type, null: false
+                    t.bigint  :subject_id,   null: false
+
                     t.timestamps
+                    t.datetime :deleted_at, index: true
                 end
 
-                add_reference(table_name, :user, foreign_key: { to_table: :lesli_users }) unless resources == :lesli_users
-                add_reference(table_name, foreign_key, foreign_key: { to_table: resources })
+                add_reference(table_name, :user, foreign_key: { to_table: :lesli_users }) 
+                add_reference(table_name, :account, foreign_key: { to_table: "#{engine}_accounts".to_sym })
+                add_index(table_name, [:account_id, :subject_type, :subject_id], name: "#{table_name}_activities_type_id")
             end
         end
     end

data/lib/migrate/items/discussion_structure.rb

@@ -33,17 +33,23 @@ Building a better future, one line of code at a time.
 module MigrationHelpers
     module Items
         module DiscussionStructure
-            def create_table_lesli_item_discussions_10(resources)
+            def create_table_lesli_item_discussions_10(engine)
 
-                table_name, foreign_key = table_name_for_item(resources, :discussions)
+                table_name, foreign_key = table_name_for_item(engine, :discussions)
     
                 create_table table_name do |t|
                     t.text :message
+
+                    # Polymorphic target
+                    t.string  :discussable_type, null: false
+                    t.bigint  :discussable_id,   null: false
+
                     t.timestamps
+                    t.datetime :deleted_at, index: true
                 end
 
                 add_reference(table_name, :user, foreign_key: { to_table: :lesli_users })
-                add_reference(table_name, foreign_key, foreign_key: { to_table: resources })
+                add_reference(table_name, :account, foreign_key: { to_table: "#{engine}_accounts".to_sym })
             end
         end
     end

data/lib/migrate/items/{action_structure.rb → task_structure.rb}

@@ -2,7 +2,7 @@
 
 Lesli
 
-Copyright (c) 2025, Lesli Technologies, S. A.
+Copyright (c) 2026, Lesli Technologies, S. A.
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -32,20 +32,26 @@ Building a better future, one line of code at a time.
 
 module MigrationHelpers
     module Items
-        module ActionStructure
-            def create_table_lesli_item_actions_10(resources)
+        module TaskStructure
+            def create_table_lesli_item_tasks_10(engine)
 
-                table_name, foreign_key = table_name_for_item(resources, :actions)
+                table_name, foreign_key = table_name_for_item(engine, :tasks)
 
                 create_table table_name do |t|
                     t.string  :title, null: false
                     t.boolean :done, default: false, null: false
-                    t.datetime :deleted_at, index: true
+
+                    # Polymorphic target
+                    t.string  :taskable_type, null: false
+                    t.bigint  :taskable_id,   null: false
+
                     t.timestamps
+                    t.datetime :deleted_at, index: true
                 end
 
                 add_reference(table_name, :user, foreign_key: { to_table: :lesli_users })
-                add_reference(table_name, foreign_key, foreign_key: { to_table: resources })
+                add_reference(table_name, :account, foreign_key: { to_table: "#{engine}_accounts".to_sym })
+                add_index(table_name, [:account_id, :taskable_type, :taskable_id], name: "#{table_name}_taskable_type_id".to_sym)
             end
         end
     end

data/lib/migrate/shared/catalog_structure.rb

@@ -2,6 +2,22 @@
 module MigrationHelpers
     module Shared
         module CatalogStructure
+            # def create_table_lesli_shared_catalogs_10(engine)
+
+            #     table_name, table_name_account = table_name_for_shared(engine, :catalogs)
+
+            #     create_table table_name do |t|
+            #         t.string    :key, index: true 
+            #         t.string    :name 
+            #         t.integer   :order
+            #         t.boolean   :default, default: false
+            #         t.timestamps 
+            #     end
+            #     add_reference(table_name, :parent, null: true, foreign_key: { to_table: table_name }, index: true)
+            #     add_reference(table_name, :catalog, null: true, foreign_key: { to_table: table_name }, index: true)
+            #     add_reference(table_name, :account, null: false, foreign_key: { to_table: table_name_account }, index: true)
+
+            # end
             def create_table_lesli_shared_catalogs_10(engine)
 
                 table_name, table_name_account = table_name_for_shared(engine, :catalogs)

data/lib/tasks/lesli/db.rake

@@ -44,6 +44,15 @@ namespace :lesli do
             status()
         end
 
+        desc "Create, migrate, seed & prepare the Lesli database (development only)"
+        task :dev => :environment do |task, args|
+            create()
+            migrate()
+            seed()
+            prepare()
+            status()
+        end
+
         desc "Migrate, prepare && user the Lesli database"
         task :deploy => :environment do |task, args|
             create()

data/readme.md

@@ -34,7 +34,7 @@
 
 ## Introduction
 
-Lesli is an open-source SaaS development framework built to create scalable, secure, and modular software products.
+Lesli is an open-source framework built to create scalable, secure, and modular software products.
 
 Built on top of **Ruby on Rails, PostgreSQL, Hotwire, and modern frontend tooling**, Lesli provides the infrastructure, architecture, and reusable components needed to build production-ready SaaS platforms faster.