terrazzo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0ff3b38b0cdec57570baa990aef1998197eba301cfa0c297d0619ff7d4003374
+  data.tar.gz: f0556e47ac6c647db017b2ebb0167a5f9585a5d3c9353bab740131fbd717b02b
+SHA512:
+  metadata.gz: b46cb63e1fe4754a6938fec445f76aa90eba36f55c3fde38f08713db3e325f504b3fe985816625a07e5a8b77e7fe6d820c62f262dd20d443deaa6566111c75db
+  data.tar.gz: '0974a53199cdbdb29b8e90096429ee853df3bbeb5414cb60d1ef2dceca0c6356a7533921a3ab383a19b04bc408e08658e8f5e4d58a55f7dbfb5caa06454ad39f'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 SuperglueAdmin Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = "spec/lib/**/*_spec.rb"
+  end
+  task default: :spec
+rescue LoadError
+  # rspec not available
+end

data/app/controllers/terrazzo/application_controller.rb

@@ -0,0 +1,208 @@
+require "superglue"
+
+module Terrazzo
+  class ApplicationController < ::ActionController::Base
+    include Superglue::Controller
+
+    prepend_view_path(
+      Superglue::Resolver.new(Terrazzo::Engine.root.join("app/views"))
+    )
+
+    prepend_view_path(
+      Superglue::Resolver.new(Rails.root.join("app/views"))
+    )
+
+    before_action :use_jsx_rendering_defaults
+
+    helper_method :namespace, :dashboard, :resource_name, :resource_class, :application_title, :terrazzo_page_identifier
+
+    def index
+      search = Terrazzo::Search.new(scoped_resource, dashboard, params[:search])
+      resources = search.run
+
+      filter = Terrazzo::Filter.new(resources, dashboard, params[:filter], params[:filter_value])
+      resources = filter.run
+
+      order = Terrazzo::Order.new(
+        attribute: params[:order] || default_sorting_attribute,
+        direction: params[:direction] || (params[:order] ? nil : default_sorting_direction)
+      )
+      resources = order.apply(resources, dashboard)
+
+      includes = dashboard.collection_includes
+      resources = resources.includes(*includes) if includes.any?
+
+      @resources = resources.page(params[:_page]).per(params[:per_page] || 25)
+      @page = Terrazzo::Page::Collection.new(dashboard, resource_class, order: order)
+      @search_term = params[:search]
+      @active_filter = params[:filter]
+      @filter_value = params[:filter_value]
+    end
+
+    def show
+      @resource = find_resource(params[:id])
+      @page = Terrazzo::Page::Show.new(dashboard, @resource)
+    end
+
+    def new
+      @resource = resource_class.new
+      @page = Terrazzo::Page::Form.new(dashboard, @resource)
+    end
+
+    def edit
+      @resource = find_resource(params[:id])
+      @page = Terrazzo::Page::Form.new(dashboard, @resource)
+    end
+
+    def create
+      @resource = resource_class.new(resource_params("create"))
+      assign_has_one_associations(@resource)
+
+      if @resource.save
+        redirect_to after_resource_created_path(@resource),
+          notice: t("terrazzo.controllers.create.success",
+            resource_name: resource_name)
+      else
+        @page = Terrazzo::Page::Form.new(dashboard, @resource)
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      @resource = find_resource(params[:id])
+
+      rp = resource_params("update")
+      assign_has_one_associations(@resource)
+
+      if @resource.update(rp)
+        redirect_to after_resource_updated_path(@resource),
+          notice: t("terrazzo.controllers.update.success",
+            resource_name: resource_name)
+      else
+        @page = Terrazzo::Page::Form.new(dashboard, @resource)
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @resource = find_resource(params[:id])
+      @resource.destroy
+
+      redirect_to after_resource_destroyed_path,
+        notice: t("terrazzo.controllers.destroy.success",
+          resource_name: resource_name)
+    end
+
+    protected
+
+    def application_title
+      Rails.application.class.module_parent_name.titleize
+    end
+
+    def default_sorting_attribute
+      nil
+    end
+
+    def default_sorting_direction
+      :asc
+    end
+
+    def after_resource_created_path(resource)
+      [namespace, resource]
+    end
+
+    def after_resource_updated_path(resource)
+      [namespace, resource]
+    end
+
+    def after_resource_destroyed_path
+      url_for(action: :index, only_path: true)
+    rescue ActionController::UrlGenerationError
+      "/"
+    end
+
+    def scoped_resource
+      resource_class.all
+    end
+
+    def find_resource(id)
+      scoped_resource.find(id)
+    rescue ActiveRecord::RecordNotFound
+      # Support models that override to_param (e.g., slug-based URLs)
+      scoped_resource.find_by!(slug: id)
+    end
+
+    def resource_params(action = nil)
+      permitted = params.require(resource_class.model_name.param_key)
+        .permit(dashboard.permitted_attributes(action))
+
+      # Transform and extract special field params
+      @has_one_assignments = {}
+      dashboard.flatten_attributes(dashboard.form_attributes(action)).each do |attr|
+        field_type = dashboard.attribute_type_for(attr)
+        klass = field_type.is_a?(Terrazzo::Field::Deferred) ? field_type.deferred_class : field_type
+
+        # Transform params (e.g., JSON string → Hash for hstore fields)
+        if permitted.key?(attr.to_s) && klass.respond_to?(:transform_param)
+          permitted[attr.to_s] = klass.transform_param(permitted[attr.to_s])
+        end
+
+        # Extract has_one virtual _id params since ActiveRecord doesn't
+        # natively support assigning has_one associations by id
+        next unless klass <= Terrazzo::Field::HasOne
+
+        id_key = "#{attr}_id"
+        if permitted.key?(id_key)
+          id_value = permitted.delete(id_key)
+          @has_one_assignments[attr] = id_value if id_value.present?
+        end
+      end
+
+      permitted
+    end
+
+    def assign_has_one_associations(resource)
+      return unless @has_one_assignments
+
+      @has_one_assignments.each do |attr, id_value|
+        reflection = resource.class.reflect_on_association(attr)
+        associated = reflection.klass.find(id_value)
+        resource.public_send(:"#{attr}=", associated)
+      end
+    end
+
+    def authorized_action?(resource, action)
+      true
+    end
+
+    def namespace
+      @_namespace ||= resolver.namespace
+    end
+
+    def dashboard
+      @_dashboard ||= resolver.dashboard_class.new
+    end
+
+    def resource_class
+      @_resource_class ||= resolver.resource_class
+    end
+
+    def resource_name
+      @_resource_name ||= resolver.resource_title
+    end
+
+    # Build a page identifier that matches the user's namespace, not the
+    # engine's internal template path. The React page-to-component mapping
+    # keys off this identifier (e.g. "admin/application/index").
+    def terrazzo_page_identifier
+      ns = controller_path.split("/").first
+      "#{ns}/application/#{action_name}"
+    end
+
+    private
+
+    def resolver
+      @_resolver ||= Terrazzo::ResourceResolver.new(controller_path)
+    end
+  end
+end

data/app/views/terrazzo/application/edit.json.props

@@ -0,0 +1,70 @@
+param_key = resource_class.model_name.param_key
+
+json.pageTitle t("terrazzo.actions.edit", resource_name: resource_name)
+
+json.form do
+  json.props({
+    action: polymorphic_path([namespace, @resource]),
+    method: "post"
+  })
+  json.extras do
+    if protect_against_forgery?
+      json.set!("authenticity_token") do
+        json.name "authenticity_token"
+        json.type "hidden"
+        json.defaultValue form_authenticity_token
+        json.autoComplete "off"
+      end
+    end
+    json.set!("_method") do
+      json.name "_method"
+      json.type "hidden"
+      json.value "patch"
+    end
+  end
+  json.fields do
+    json.array! @page.attributes("update") do |field|
+      json.attribute field.attribute.to_s
+      json.label field.attribute.to_s.humanize
+      json.fieldType field.field_type
+      json.value field.serialize_value(:form)
+      json.options field.serializable_options
+      json.required field.required?
+      json.input field.form_input_attributes(param_key)
+    end
+  end
+  json.fieldGroups do
+    json.array! @page.grouped_attributes("update") do |group|
+      json.name group[:name]
+      json.fields do
+        json.array! group[:fields] do |field|
+          json.attribute field.attribute.to_s
+          json.label field.attribute.to_s.humanize
+          json.fieldType field.field_type
+          json.value field.serialize_value(:form)
+          json.options field.serializable_options
+          json.required field.required?
+          json.input field.form_input_attributes(param_key)
+        end
+      end
+    end
+  end
+end
+
+json.errors @resource.errors.full_messages
+
+json.showPath polymorphic_path([namespace, @resource])
+json.indexPath begin
+  url_for(controller: controller_path, action: :index, only_path: true)
+rescue ActionController::UrlGenerationError
+  nil
+end
+json.resourceName resource_name
+
+json.navigation do
+  json.array! Terrazzo::Namespace.new(namespace).resources_with_index_route do |nav_resource|
+    json.label nav_resource.resource_name.humanize.pluralize
+    json.path url_for(controller: "/#{nav_resource.controller_path}", action: :index, only_path: true)
+    json.active nav_resource.controller_path == controller_path
+  end
+end

data/app/views/terrazzo/application/index.json.props

@@ -0,0 +1,97 @@
+json.searchBar do
+  json.searchTerm @search_term
+  json.searchPath request.path
+end
+
+json.filters do
+  json.available dashboard.collection_filters.keys.map(&:to_s)
+  json.active @active_filter
+  json.value @filter_value
+end
+
+json.table do
+  json.headers do
+    json.array! @page.attribute_names do |attr|
+      field_class = dashboard.attribute_type_for(attr)
+      json.label attr.to_s.humanize
+      json.attribute attr.to_s
+      json.sortable field_class.sortable?
+      json.sortDirection @page.sort_direction_for(attr)
+      json.sortUrl url_for(
+        @page.order_params_for(attr).merge(
+          search: @search_term,
+          filter: @active_filter,
+          filter_value: @filter_value,
+          _page: 1,
+          only_path: true
+        )
+      )
+    end
+  end
+
+  json.rows do
+    json.array! @resources do |resource|
+      json.id resource.id
+      json.showPath polymorphic_path([namespace, resource]) rescue nil
+      json.editPath edit_polymorphic_path([namespace, resource]) rescue nil
+      json.deletePath polymorphic_path([namespace, resource]) rescue nil
+
+      json.cells do
+        json.array! @page.attribute_names do |attr|
+          field = dashboard.attribute_type_for(attr).new(attr, nil, :index, resource: resource)
+          json.attribute attr.to_s
+          json.fieldType field.field_type
+          json.value field.serialize_value(:index)
+          json.options field.serializable_options
+        end
+      end
+    end
+  end
+end
+
+json.pagination do
+  json.currentPage @resources.current_page
+  json.totalPages @resources.total_pages
+  json.totalCount @resources.total_count
+  json.perPage @resources.limit_value
+  if @resources.next_page
+    json.nextPagePath url_for(
+      _page: @resources.next_page,
+      search: @search_term,
+      order: params[:order],
+      direction: params[:direction],
+      filter: @active_filter,
+      filter_value: @filter_value,
+      props_at: "data.pagination",
+      only_path: true
+    )
+  else
+    json.nextPagePath nil
+  end
+  if @resources.prev_page
+    json.prevPagePath url_for(
+      _page: @resources.prev_page,
+      search: @search_term,
+      order: params[:order],
+      direction: params[:direction],
+      filter: @active_filter,
+      filter_value: @filter_value,
+      props_at: "data.pagination",
+      only_path: true
+    )
+  else
+    json.prevPagePath nil
+  end
+end
+
+json.resourceName resource_name.pluralize
+json.singularResourceName resource_name
+json.newResourcePath new_polymorphic_path([namespace, resource_class]) rescue nil
+
+json.navigation do
+  json.array! Terrazzo::Namespace.new(namespace).resources_with_index_route do |nav_resource|
+    json.label nav_resource.resource_name.humanize.pluralize
+    json.path url_for(controller: "/#{nav_resource.controller_path}", action: :index, only_path: true)
+    json.active nav_resource.controller_path == controller_path
+  end
+end

data/app/views/terrazzo/application/new.json.props

@@ -0,0 +1,65 @@
+action = @resource.persisted? ? "update" : "create"
+param_key = resource_class.model_name.param_key
+
+json.pageTitle t("terrazzo.actions.new", resource_name: resource_name)
+
+json.form do
+  json.props({
+    action: polymorphic_path([namespace, resource_class]),
+    method: "post"
+  })
+  json.extras do
+    if protect_against_forgery?
+      json.set!("authenticity_token") do
+        json.name "authenticity_token"
+        json.type "hidden"
+        json.defaultValue form_authenticity_token
+        json.autoComplete "off"
+      end
+    end
+  end
+  json.fields do
+    json.array! @page.attributes(action) do |field|
+      json.attribute field.attribute.to_s
+      json.label field.attribute.to_s.humanize
+      json.fieldType field.field_type
+      json.value field.serialize_value(:form)
+      json.options field.serializable_options
+      json.required field.required?
+      json.input field.form_input_attributes(param_key)
+    end
+  end
+  json.fieldGroups do
+    json.array! @page.grouped_attributes(action) do |group|
+      json.name group[:name]
+      json.fields do
+        json.array! group[:fields] do |field|
+          json.attribute field.attribute.to_s
+          json.label field.attribute.to_s.humanize
+          json.fieldType field.field_type
+          json.value field.serialize_value(:form)
+          json.options field.serializable_options
+          json.required field.required?
+          json.input field.form_input_attributes(param_key)
+        end
+      end
+    end
+  end
+end
+
+json.errors @resource.errors.full_messages
+
+json.indexPath begin
+  url_for(controller: controller_path, action: :index, only_path: true)
+rescue ActionController::UrlGenerationError
+  nil
+end
+json.resourceName resource_name
+
+json.navigation do
+  json.array! Terrazzo::Namespace.new(namespace).resources_with_index_route do |nav_resource|
+    json.label nav_resource.resource_name.humanize.pluralize
+    json.path url_for(controller: "/#{nav_resource.controller_path}", action: :index, only_path: true)
+    json.active nav_resource.controller_path == controller_path
+  end
+end

data/app/views/terrazzo/application/show.json.props

@@ -0,0 +1,44 @@
+json.pageTitle @page.page_title
+
+json.attributeGroups do
+  json.array! @page.grouped_attributes do |group|
+    json.name group[:name]
+    json.attributes do
+      json.array! group[:fields] do |field|
+        json.attribute field.attribute.to_s
+        json.label field.attribute.to_s.humanize
+        json.fieldType field.field_type
+        json.value field.serialize_value(:show)
+        json.options field.serializable_options
+      end
+    end
+  end
+end
+
+json.attributes do
+  json.array! @page.attributes do |field|
+    json.attribute field.attribute.to_s
+    json.label field.attribute.to_s.humanize
+    json.fieldType field.field_type
+    json.value field.serialize_value(:show)
+    json.options field.serializable_options
+  end
+end
+
+json.editPath edit_polymorphic_path([namespace, @resource]) rescue nil
+json.deletePath polymorphic_path([namespace, @resource]) rescue nil
+json.indexPath begin
+  url_for(controller: controller_path, action: :index, only_path: true)
+rescue ActionController::UrlGenerationError
+  nil
+end
+json.resourceName resource_name
+json.pluralResourceName resource_name.pluralize
+
+json.navigation do
+  json.array! Terrazzo::Namespace.new(namespace).resources_with_index_route do |nav_resource|
+    json.label nav_resource.resource_name.humanize.pluralize
+    json.path url_for(controller: "/#{nav_resource.controller_path}", action: :index, only_path: true)
+    json.active nav_resource.controller_path == controller_path
+  end
+end

data/app/views/terrazzo/application/superglue.html.erb

@@ -0,0 +1,5 @@
+<script type="text/javascript">
+  window.SUPERGLUE_INITIAL_PAGE_STATE=<%= render_props %>;<%# erblint:disable ErbSafety %>
+</script>
+
+<div id="superglue-app"></div>

data/config/locales/en.yml

@@ -0,0 +1,28 @@
+en:
+  terrazzo:
+    actions:
+      new: "New %{resource_name}"
+      edit: "Edit %{resource_name}"
+      show: "Show %{resource_name}"
+      destroy: "Delete %{resource_name}"
+      confirm_destroy: "Are you sure you want to delete this %{resource_name}?"
+      back: "Back"
+      save: "Save"
+      cancel: "Cancel"
+    controllers:
+      create:
+        success: "%{resource_name} was successfully created."
+      update:
+        success: "%{resource_name} was successfully updated."
+      destroy:
+        success: "%{resource_name} was successfully destroyed."
+    search:
+      placeholder: "Search %{resource_name}..."
+      clear: "Clear search"
+    pagination:
+      previous: "Previous"
+      next: "Next"
+      page_info: "Page %{current} of %{total}"
+      total_count: "%{count} total"
+    navigation:
+      title: "Admin"

data/lib/generators/terrazzo/dashboard/dashboard_generator.rb

@@ -0,0 +1,118 @@
+require "rails/generators"
+require "terrazzo/generator_helpers"
+
+module Terrazzo
+  module Generators
+    class DashboardGenerator < Rails::Generators::NamedBase
+      include Terrazzo::GeneratorHelpers
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :namespace, type: :string, default: "admin",
+        desc: "Admin namespace"
+      class_option :bundler, type: :string, default: "vite",
+        desc: "JavaScript bundler (vite or sprockets)"
+
+      def create_dashboard
+        template "dashboard.rb.erb",
+          "app/dashboards/#{file_name}_dashboard.rb"
+      end
+
+      def create_controller
+        template "controller.rb.erb",
+          "app/controllers/#{options[:namespace]}/#{file_name.pluralize}_controller.rb"
+      end
+
+      def update_page_to_page_mapping
+        return if options[:bundler] == "vite"
+
+        mapping_path = "app/javascript/#{options[:namespace]}/page_to_page_mapping.js"
+        return unless File.exist?(mapping_path)
+
+        namespace_name = options[:namespace]
+        action_to_component = {
+          "index" => "AdminIndex",
+          "show" => "AdminShow",
+          "new" => "AdminNew",
+          "edit" => "AdminEdit"
+        }
+
+        action_to_component.each do |action, component|
+          key = "'#{namespace_name}/application/#{action}'"
+          mapping_path_content = File.read(mapping_path)
+          next if mapping_path_content.include?(key)
+
+          inject_into_file mapping_path, before: "}" do
+            "  #{key}: #{component},\n"
+          end
+        end
+      end
+
+      private
+
+      def model_class
+        class_name.constantize
+      end
+
+      def attribute_types
+        columns = model_class.columns.reject { |c| c.name == "id" }
+        associations = model_class.reflect_on_all_associations
+
+        types = {}
+
+        # ID first
+        types[:id] = "Field::Number"
+
+        # Columns
+        columns.each do |col|
+          next if col.name.end_with?("_type") && columns.any? { |c| c.name == col.name.sub(/_type$/, "_id") }
+          next if association_foreign_key?(col.name, associations)
+
+          types[col.name.to_sym] = column_to_field_type(col)
+        end
+
+        # Associations
+        associations.each do |assoc|
+          case assoc.macro
+          when :belongs_to
+            types[assoc.name] = "Field::BelongsTo"
+          when :has_many, :has_and_belongs_to_many
+            types[assoc.name] = "Field::HasMany"
+          when :has_one
+            types[assoc.name] = "Field::HasOne"
+          end
+        end
+
+        types
+      end
+
+      def collection_attributes
+        attrs = attribute_types.keys.reject { |a| %i[created_at updated_at].include?(a) }
+        attrs.first(4)
+      end
+
+      def show_page_attributes
+        attribute_types.keys
+      end
+
+      def form_attributes
+        attribute_types.keys.reject { |a| %i[id created_at updated_at].include?(a) }
+      end
+
+      def association_foreign_key?(column_name, associations)
+        associations.any? do |assoc|
+          assoc.macro == :belongs_to &&
+            assoc.foreign_key.to_s == column_name
+        end
+      end
+
+      def has_enum?(column_name)
+        model_class.defined_enums.key?(column_name.to_s)
+      end
+
+      def enum_collection(column_name)
+        model_class.defined_enums[column_name.to_s]&.keys || []
+      end
+    end
+  end
+end

data/lib/generators/terrazzo/dashboard/templates/controller.rb.erb

@@ -0,0 +1,4 @@
+module <%= options[:namespace].camelize %>
+  class <%= class_name.pluralize %>Controller < ApplicationController
+  end
+end