tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/orm.rb

@@ -7,32 +7,131 @@ module Tina4
 
     class << self
       def db
-        Tina4.database
+        @db || Tina4.database
       end
 
-      def find(id)
-        pk = primary_key_field || :id
-        result = db.fetch_one("SELECT * FROM #{table_name} WHERE #{pk} = ?", [id])
-        return nil unless result
-        from_hash(result)
+      # Per-model database binding
+      def db=(database)
+        @db = database
+      end
+
+      # Soft delete configuration
+      def soft_delete
+        @soft_delete || false
+      end
+
+      def soft_delete=(val)
+        @soft_delete = val
+      end
+
+      def soft_delete_field
+        @soft_delete_field || :is_deleted
+      end
+
+      def soft_delete_field=(val)
+        @soft_delete_field = val
+      end
+
+      # Field mapping: { 'db_column' => 'ruby_attribute' }
+      def field_mapping
+        @field_mapping || {}
+      end
+
+      def field_mapping=(map)
+        @field_mapping = map
+      end
+
+      # Relationship definitions
+      def relationship_definitions
+        @relationship_definitions ||= {}
+      end
+
+      # has_one :profile, class_name: "Profile", foreign_key: "user_id"
+      def has_one(name, class_name: nil, foreign_key: nil)
+        relationship_definitions[name] = {
+          type: :has_one,
+          class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
+          foreign_key: foreign_key
+        }
+
+        define_method(name) do
+          load_has_one(name)
+        end
+      end
+
+      # has_many :posts, class_name: "Post", foreign_key: "user_id"
+      def has_many(name, class_name: nil, foreign_key: nil)
+        relationship_definitions[name] = {
+          type: :has_many,
+          class_name: class_name || name.to_s.sub(/s$/, "").split("_").map(&:capitalize).join,
+          foreign_key: foreign_key
+        }
+
+        define_method(name) do
+          load_has_many(name)
+        end
+      end
+
+      # belongs_to :user, class_name: "User", foreign_key: "user_id"
+      def belongs_to(name, class_name: nil, foreign_key: nil)
+        relationship_definitions[name] = {
+          type: :belongs_to,
+          class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
+          foreign_key: foreign_key || "#{name}_id"
+        }
+
+        define_method(name) do
+          load_belongs_to(name)
+        end
+      end
+
+      def find(id_or_filter = nil, filter = nil)
+        # find(id) — find by primary key
+        # find(filter_hash) — find by criteria
+        if id_or_filter.is_a?(Hash)
+          find_by_filter(id_or_filter)
+        elsif filter.is_a?(Hash)
+          find_by_filter(filter)
+        else
+          find_by_id(id_or_filter)
+        end
       end
 
       def where(conditions, params = [])
-        sql = "SELECT * FROM #{table_name} WHERE #{conditions}"
+        sql = "SELECT * FROM #{table_name}"
+        if soft_delete
+          sql += " WHERE (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0) AND (#{conditions})"
+        else
+          sql += " WHERE #{conditions}"
+        end
         results = db.fetch(sql, params)
         results.map { |row| from_hash(row) }
       end
 
-      def all(limit: nil, skip: nil, order_by: nil)
+      def all(limit: nil, offset: nil, skip: nil, order_by: nil)
         sql = "SELECT * FROM #{table_name}"
+        if soft_delete
+          sql += " WHERE #{soft_delete_field} IS NULL OR #{soft_delete_field} = 0"
+        end
         sql += " ORDER BY #{order_by}" if order_by
-        results = db.fetch(sql, [], limit: limit, skip: skip)
+        effective_offset = offset || skip
+        results = db.fetch(sql, [], limit: limit, skip: effective_offset)
+        results.map { |row| from_hash(row) }
+      end
+
+      def select(sql, params = [], limit: nil, skip: nil)
+        results = db.fetch(sql, params, limit: limit, skip: skip)
         results.map { |row| from_hash(row) }
       end
 
       def count(conditions = nil, params = [])
         sql = "SELECT COUNT(*) as cnt FROM #{table_name}"
-        sql += " WHERE #{conditions}" if conditions
+        where_parts = []
+        if soft_delete
+          where_parts << "(#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
+        end
+        where_parts << "(#{conditions})" if conditions
+        sql += " WHERE #{where_parts.join(' AND ')}" unless where_parts.empty?
         result = db.fetch_one(sql, params)
         result[:cnt].to_i
       end
@@ -43,28 +142,113 @@ module Tina4
         instance
       end
 
+      def find_or_fail(id)
+        result = find(id)
+        raise "#{name} with #{primary_key_field || :id}=#{id} not found" if result.nil?
+        result
+      end
+
+      def with_trashed(conditions = "1=1", params = [], limit: 20, skip: 0)
+        sql = "SELECT * FROM #{table_name} WHERE #{conditions}"
+        results = db.fetch(sql, params, limit: limit, skip: skip)
+        results.map { |row| from_hash(row) }
+      end
+
+      def create_table
+        return true if db.table_exists?(table_name)
+
+        type_map = {
+          integer: "INTEGER",
+          string: "VARCHAR(255)",
+          text: "TEXT",
+          float: "REAL",
+          decimal: "REAL",
+          boolean: "INTEGER",
+          date: "DATE",
+          datetime: "DATETIME",
+          timestamp: "TIMESTAMP",
+          blob: "BLOB",
+          json: "TEXT"
+        }
+
+        col_defs = []
+        field_definitions.each do |name, opts|
+          sql_type = type_map[opts[:type]] || "TEXT"
+          if opts[:type] == :string && opts[:length]
+            sql_type = "VARCHAR(#{opts[:length]})"
+          end
+
+          parts = ["#{name} #{sql_type}"]
+          parts << "PRIMARY KEY" if opts[:primary_key]
+          parts << "AUTOINCREMENT" if opts[:auto_increment]
+          parts << "NOT NULL" if !opts[:nullable] && !opts[:primary_key]
+          if opts[:default] && !opts[:auto_increment]
+            default_val = opts[:default].is_a?(String) ? "'#{opts[:default]}'" : opts[:default]
+            parts << "DEFAULT #{default_val}"
+          end
+          col_defs << parts.join(" ")
+        end
+
+        sql = "CREATE TABLE IF NOT EXISTS #{table_name} (#{col_defs.join(', ')})"
+        db.execute(sql)
+        true
+      end
+
+      def scope(name, filter_sql, params = [])
+        define_singleton_method(name) do |limit: 20, skip: 0|
+          where(filter_sql, params)
+        end
+      end
+
       def from_hash(hash)
         instance = new
+        mapping_reverse = field_mapping.invert
         hash.each do |key, value|
-          setter = "#{key}="
-          instance.send(setter, value) if instance.respond_to?(setter)
+          # Apply field mapping (db_col => ruby_attr)
+          attr_name = mapping_reverse[key.to_s] || key
+          setter = "#{attr_name}="
+          instance.__send__(setter, value) if instance.respond_to?(setter)
         end
         instance.instance_variable_set(:@persisted, true)
         instance
       end
+
+      private
+
+      def find_by_id(id)
+        pk = primary_key_field || :id
+        sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
+        if soft_delete
+          sql += " AND (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
+        end
+        result = db.fetch_one(sql, [id])
+        return nil unless result
+        from_hash(result)
+      end
+
+      def find_by_filter(filter)
+        where_parts = filter.keys.map { |k| "#{k} = ?" }
+        sql = "SELECT * FROM #{table_name} WHERE #{where_parts.join(' AND ')}"
+        if soft_delete
+          sql += " AND (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
+        end
+        results = db.fetch(sql, filter.values)
+        results.map { |row| from_hash(row) }
+      end
     end
 
     def initialize(attributes = {})
       @persisted = false
       @errors = []
+      @relationship_cache = {}
       attributes.each do |key, value|
         setter = "#{key}="
-        send(setter, value) if respond_to?(setter)
+        __send__(setter, value) if respond_to?(setter)
       end
       # Set defaults
       self.class.field_definitions.each do |name, opts|
-        if send(name).nil? && opts[:default]
-          send("#{name}=", opts[:default])
+        if __send__(name).nil? && opts[:default]
+          __send__("#{name}=", opts[:default])
         end
       end
     end
@@ -74,18 +258,21 @@ module Tina4
       validate_fields
       return false unless @errors.empty?
 
-      data = to_hash(exclude_nil: true)
+      data = to_db_hash(exclude_nil: true)
       pk = self.class.primary_key_field || :id
-      pk_value = send(pk)
+      pk_value = __send__(pk)
 
       if @persisted && pk_value
         filter = { pk => pk_value }
         data.delete(pk)
+        # Remove mapped primary key too
+        mapped_pk = self.class.field_mapping[pk.to_s]
+        data.delete(mapped_pk.to_sym) if mapped_pk
         self.class.db.update(self.class.table_name, data, filter)
       else
         result = self.class.db.insert(self.class.table_name, data)
         if result[:last_id] && respond_to?("#{pk}=")
-          send("#{pk}=", result[:last_id])
+          __send__("#{pk}=", result[:last_id])
         end
         @persisted = true
       end
@@ -97,25 +284,75 @@ module Tina4
 
     def delete
       pk = self.class.primary_key_field || :id
-      pk_value = send(pk)
+      pk_value = __send__(pk)
       return false unless pk_value
 
+      if self.class.soft_delete
+        # Soft delete: set the flag
+        self.class.db.update(
+          self.class.table_name,
+          { self.class.soft_delete_field => 1 },
+          { pk => pk_value }
+        )
+      else
+        self.class.db.delete(self.class.table_name, { pk => pk_value })
+      end
+      @persisted = false
+      true
+    end
+
+    def force_delete
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      raise "Cannot delete: no primary key value" unless pk_value
+
       self.class.db.delete(self.class.table_name, { pk => pk_value })
       @persisted = false
       true
     end
 
+    def restore
+      raise "Model does not support soft delete" unless self.class.soft_delete
+
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      raise "Cannot restore: no primary key value" unless pk_value
+
+      self.class.db.update(
+        self.class.table_name,
+        { self.class.soft_delete_field => 0 },
+        { pk => pk_value }
+      )
+      __send__("#{self.class.soft_delete_field}=", 0) if respond_to?("#{self.class.soft_delete_field}=")
+      true
+    end
+
+    def validate
+      errors = []
+      self.class.field_definitions.each do |name, opts|
+        value = __send__(name)
+        if !opts[:nullable] && value.nil? && !opts[:auto_increment] && !opts[:default]
+          errors << "#{name} cannot be null"
+        end
+      end
+      errors
+    end
+
     def load(id = nil)
       pk = self.class.primary_key_field || :id
-      id ||= send(pk)
+      id ||= __send__(pk)
       return false unless id
 
-      result = self.class.db.fetch_one("SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id])
+      result = self.class.db.fetch_one(
+        "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id]
+      )
       return false unless result
 
+      mapping_reverse = self.class.field_mapping.invert
       result.each do |key, value|
-        setter = "#{key}="
-        send(setter, value) if respond_to?(setter)
+        attr_name = mapping_reverse[key.to_s] || key
+        setter = "#{attr_name}="
+        __send__(setter, value) if respond_to?(setter)
       end
       @persisted = true
       true
@@ -129,40 +366,109 @@ module Tina4
       @errors
     end
 
-    def to_hash(exclude_nil: false)
+    # Convert to hash using Ruby attribute names
+    def to_h
       hash = {}
       self.class.field_definitions.each_key do |name|
-        value = send(name)
-        next if exclude_nil && value.nil?
-        hash[name] = value
+        hash[name] = __send__(name)
       end
       hash
     end
 
+    alias to_hash to_h
+    alias to_dict to_h
+    alias to_object to_h
+
+    def to_array
+      to_h.values
+    end
+
+    alias to_list to_array
+
     def to_json(*_args)
-      JSON.generate(to_hash)
+      JSON.generate(to_h)
     end
 
     def to_s
-      "#<#{self.class.name} #{to_hash}>"
+      "#<#{self.class.name} #{to_h}>"
     end
 
     def select(*fields)
       fields_str = fields.map(&:to_s).join(", ")
       pk = self.class.primary_key_field || :id
-      pk_value = send(pk)
+      pk_value = __send__(pk)
       self.class.db.fetch_one("SELECT #{fields_str} FROM #{self.class.table_name} WHERE #{pk} = ?", [pk_value])
     end
 
     private
 
+    # Convert to hash using DB column names (with field_mapping applied)
+    def to_db_hash(exclude_nil: false)
+      hash = {}
+      mapping = self.class.field_mapping
+      self.class.field_definitions.each_key do |name|
+        value = __send__(name)
+        next if exclude_nil && value.nil?
+        db_col = mapping[name.to_s] || name
+        hash[db_col.to_sym] = value
+      end
+      hash
+    end
+
     def validate_fields
       self.class.field_definitions.each do |name, opts|
-        value = send(name)
+        value = __send__(name)
         if !opts[:nullable] && value.nil? && !opts[:auto_increment] && !opts[:default]
           @errors << "#{name} cannot be null"
         end
       end
     end
+
+    def load_has_one(name)
+      return @relationship_cache[name] if @relationship_cache.key?(name)
+      rel = self.class.relationship_definitions[name]
+      return nil unless rel
+
+      klass = Object.const_get(rel[:class_name])
+      pk = self.class.primary_key_field || :id
+      fk = rel[:foreign_key] || "#{self.class.name.split('::').last.downcase}_id"
+      pk_value = __send__(pk)
+      return nil unless pk_value
+
+      result = klass.db.fetch_one(
+        "SELECT * FROM #{klass.table_name} WHERE #{fk} = ?", [pk_value]
+      )
+      @relationship_cache[name] = result ? klass.from_hash(result) : nil
+    end
+
+    def load_has_many(name)
+      return @relationship_cache[name] if @relationship_cache.key?(name)
+      rel = self.class.relationship_definitions[name]
+      return [] unless rel
+
+      klass = Object.const_get(rel[:class_name])
+      pk = self.class.primary_key_field || :id
+      fk = rel[:foreign_key] || "#{self.class.name.split('::').last.downcase}_id"
+      pk_value = __send__(pk)
+      return [] unless pk_value
+
+      results = klass.db.fetch(
+        "SELECT * FROM #{klass.table_name} WHERE #{fk} = ?", [pk_value]
+      )
+      @relationship_cache[name] = results.map { |row| klass.from_hash(row) }
+    end
+
+    def load_belongs_to(name)
+      return @relationship_cache[name] if @relationship_cache.key?(name)
+      rel = self.class.relationship_definitions[name]
+      return nil unless rel
+
+      klass = Object.const_get(rel[:class_name])
+      fk = rel[:foreign_key] || "#{name}_id"
+      fk_value = __send__(fk.to_sym) if respond_to?(fk.to_sym)
+      return nil unless fk_value
+
+      @relationship_cache[name] = klass.find(fk_value)
+    end
   end
 end

data/lib/tina4/public/css/tina4.css

@@ -1,4 +1,3 @@
-/* Tina4 CSS Framework v2.0.0 | MIT License | https://github.com/tina4stack/tina4-css */
 *,
 *::before,
 *::after {
@@ -1515,6 +1514,64 @@ textarea.form-control {
   background-color: #212529;
 }
 
+.pagination {
+  display: flex;
+  flex-wrap: wrap;
+  padding-left: 0;
+  list-style: none;
+  gap: 0.25rem;
+}
+
+.page-item.disabled .page-link {
+  color: #6c757d;
+  pointer-events: none;
+  background-color: #fff;
+  border-color: rgba(0, 0, 0, 0.1);
+}
+
+.page-item.active .page-link {
+  color: #fff;
+  background-color: #4a90d9;
+  border-color: #4a90d9;
+}
+
+.page-link {
+  display: block;
+  padding: 0.375rem 0.75rem;
+  color: #4a90d9;
+  background-color: #fff;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  border-radius: 0.25rem;
+  text-decoration: none;
+  line-height: 1.25;
+  transition: color 0.15s, background-color 0.15s, border-color 0.15s;
+}
+
+.page-link:hover {
+  color: #2a76c6;
+  background-color: rgba(74, 144, 217, 0.08);
+  border-color: rgba(0, 0, 0, 0.2);
+}
+
+.page-link:focus {
+  outline: 0;
+  box-shadow: 0 0 0 0.2rem rgba(74, 144, 217, 0.25);
+}
+
+.crud-img-preview {
+  max-height: 200px;
+  max-width: 100%;
+  border-radius: 0.25rem;
+  object-fit: cover;
+}
+
+.crud-img-preview-sm {
+  max-height: 180px;
+  max-width: 100%;
+  border-radius: 0.25rem;
+  object-fit: cover;
+}
+
 .d-none {
   display: none !important;
 }
@@ -1793,6 +1850,66 @@ textarea.form-control {
   margin-right: 3rem !important;
 }
 
+.my-0 {
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+
+.mx-0 {
+  margin-left: 0 !important;
+  margin-right: 0 !important;
+}
+
+.my-1 {
+  margin-top: 0.25rem !important;
+  margin-bottom: 0.25rem !important;
+}
+
+.mx-1 {
+  margin-left: 0.25rem !important;
+  margin-right: 0.25rem !important;
+}
+
+.my-2 {
+  margin-top: 0.5rem !important;
+  margin-bottom: 0.5rem !important;
+}
+
+.mx-2 {
+  margin-left: 0.5rem !important;
+  margin-right: 0.5rem !important;
+}
+
+.my-3 {
+  margin-top: 1rem !important;
+  margin-bottom: 1rem !important;
+}
+
+.mx-3 {
+  margin-left: 1rem !important;
+  margin-right: 1rem !important;
+}
+
+.my-4 {
+  margin-top: 1.5rem !important;
+  margin-bottom: 1.5rem !important;
+}
+
+.mx-4 {
+  margin-left: 1.5rem !important;
+  margin-right: 1.5rem !important;
+}
+
+.my-5 {
+  margin-top: 3rem !important;
+  margin-bottom: 3rem !important;
+}
+
+.mx-5 {
+  margin-left: 3rem !important;
+  margin-right: 3rem !important;
+}
+
 .p-0 {
   padding: 0 !important;
 }
@@ -1913,6 +2030,66 @@ textarea.form-control {
   padding-right: 3rem !important;
 }
 
+.py-0 {
+  padding-top: 0 !important;
+  padding-bottom: 0 !important;
+}
+
+.px-0 {
+  padding-left: 0 !important;
+  padding-right: 0 !important;
+}
+
+.py-1 {
+  padding-top: 0.25rem !important;
+  padding-bottom: 0.25rem !important;
+}
+
+.px-1 {
+  padding-left: 0.25rem !important;
+  padding-right: 0.25rem !important;
+}
+
+.py-2 {
+  padding-top: 0.5rem !important;
+  padding-bottom: 0.5rem !important;
+}
+
+.px-2 {
+  padding-left: 0.5rem !important;
+  padding-right: 0.5rem !important;
+}
+
+.py-3 {
+  padding-top: 1rem !important;
+  padding-bottom: 1rem !important;
+}
+
+.px-3 {
+  padding-left: 1rem !important;
+  padding-right: 1rem !important;
+}
+
+.py-4 {
+  padding-top: 1.5rem !important;
+  padding-bottom: 1.5rem !important;
+}
+
+.px-4 {
+  padding-left: 1.5rem !important;
+  padding-right: 1.5rem !important;
+}
+
+.py-5 {
+  padding-top: 3rem !important;
+  padding-bottom: 3rem !important;
+}
+
+.px-5 {
+  padding-left: 3rem !important;
+  padding-right: 3rem !important;
+}
+
 .mx-auto {
   margin-left: auto !important;
   margin-right: auto !important;