aven 0.0.3

data/app/models/aven/item/linkable.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Aven
+  module Item::Linkable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :outgoing_links, class_name: "Aven::ItemLink", foreign_key: :source_id, dependent: :destroy
+      has_many :incoming_links, class_name: "Aven::ItemLink", foreign_key: :target_id, dependent: :destroy
+
+      after_save :persist_pending_links
+    end
+
+    private
+
+      def persist_pending_links
+        persist_pending_link_ids if @_pending_links.present?
+        persist_pending_link_attrs if @_pending_link_attrs.present?
+
+        @_pending_links = nil
+        @_pending_link_attrs = nil
+      end
+
+      def persist_pending_link_ids
+        @_pending_links.each do |relation_name, ids|
+          config = schema_links[relation_name]
+          next unless config
+
+          # Delete existing links for this relation
+          Aven::ItemLink.where(source_id: id, relation: relation_name.to_s).delete_all
+
+          if config[:cardinality] == :many
+            Array(ids).each_with_index do |target_id, position|
+              next unless Aven::Item.exists?(target_id)
+              Aven::ItemLink.create!(source_id: id, target_id:, relation: relation_name.to_s, position:)
+            end
+          else
+            if ids.present? && Aven::Item.exists?(ids)
+              Aven::ItemLink.create!(source_id: id, target_id: ids, relation: relation_name.to_s)
+            end
+          end
+        end
+      end
+
+      def persist_pending_link_attrs
+        @_pending_link_attrs.each do |relation_name, pending_data|
+          config = pending_data[:config]
+          attrs_list = pending_data[:attrs]
+          target_schema_slug = pending_data[:target_schema_slug]
+
+          if config[:cardinality] == :many
+            persist_many_link_attrs(relation_name, attrs_list, target_schema_slug)
+          else
+            persist_one_link_attrs(relation_name, attrs_list.first, target_schema_slug)
+          end
+        end
+      end
+
+      def persist_many_link_attrs(relation_name, attrs_list, target_schema_slug)
+        attrs_list.each_with_index do |attrs, position|
+          attr_hash = attrs.with_indifferent_access
+
+          if destroy_link_flag?(attr_hash)
+            # Delete the link (not the target item)
+            if attr_hash[:id].present?
+              Aven::ItemLink.where(source_id: id, target_id: attr_hash[:id], relation: relation_name.to_s).delete_all
+            end
+          elsif attr_hash[:id].present?
+            # Update existing
+            target = Aven::Item.find_by(id: attr_hash[:id])
+            if target
+              update_item_data(target, attr_hash.except(:id, :_destroy))
+              # Update position if link exists
+              link = Aven::ItemLink.find_by(source_id: id, target_id: target.id, relation: relation_name.to_s)
+              link&.update!(position:)
+            end
+          else
+            # Create new
+            next if attr_hash.except(:_destroy).blank?
+
+            data_attrs, nested_attrs = split_attrs(attr_hash)
+            target = Aven::Item.create!(
+              workspace:,
+              schema_slug: target_schema_slug,
+              data: data_attrs
+            )
+            # Apply nested attributes after creation
+            apply_nested_attrs(target, nested_attrs)
+            Aven::ItemLink.create!(source_id: id, target_id: target.id, relation: relation_name.to_s, position:)
+          end
+        end
+      end
+
+      def persist_one_link_attrs(relation_name, attrs, target_schema_slug)
+        return unless attrs
+
+        attr_hash = attrs.with_indifferent_access
+
+        if destroy_link_flag?(attr_hash)
+          # Delete the link
+          Aven::ItemLink.where(source_id: id, relation: relation_name.to_s).delete_all
+        elsif attr_hash[:id].present?
+          # Update existing
+          target = Aven::Item.find_by(id: attr_hash[:id])
+          update_item_data(target, attr_hash.except(:id, :_destroy)) if target
+        else
+          # Create new - first remove existing link
+          Aven::ItemLink.where(source_id: id, relation: relation_name.to_s).delete_all
+          return if attr_hash.except(:_destroy).blank?
+
+          data_attrs, nested_attrs = split_attrs(attr_hash)
+          target = Aven::Item.create!(
+            workspace:,
+            schema_slug: target_schema_slug,
+            data: data_attrs
+          )
+          # Apply nested attributes after creation
+          apply_nested_attrs(target, nested_attrs)
+          Aven::ItemLink.create!(source_id: id, target_id: target.id, relation: relation_name.to_s)
+        end
+      end
+
+      def update_item_data(item, attrs)
+        attrs.each do |key, value|
+          key_str = key.to_s
+          # Handle nested attributes (e.g., notes_attributes)
+          if key_str.end_with?("_attributes")
+            item.send("#{key_str}=", value)
+          else
+            item.data[key_str] = value
+          end
+        end
+        item.save!
+      end
+
+      def split_attrs(attrs)
+        # Split attrs into data fields and nested *_attributes
+        data_attrs = {}
+        nested_attrs = {}
+
+        attrs.each do |key, value|
+          key_str = key.to_s
+          next if key_str == "id" || key_str == "_destroy"
+
+          if key_str.end_with?("_attributes")
+            nested_attrs[key_str] = value
+          else
+            data_attrs[key_str] = value
+          end
+        end
+
+        [data_attrs, nested_attrs]
+      end
+
+      def apply_nested_attrs(item, nested_attrs)
+        return if nested_attrs.blank?
+
+        nested_attrs.each do |key, value|
+          item.send("#{key}=", value)
+        end
+        item.save!
+      end
+
+      def clean_link_attrs(attrs)
+        # Only return data fields (exclude id, _destroy, and *_attributes)
+        result = {}
+        attrs.each do |key, value|
+          key_str = key.to_s
+          next if key_str == "id" || key_str == "_destroy" || key_str.end_with?("_attributes")
+          result[key_str] = value
+        end
+        result
+      end
+
+      def destroy_link_flag?(attrs)
+        val = attrs[:_destroy] || attrs["_destroy"]
+        val == "1" || val == true
+      end
+
+      def process_link_attributes(name, attrs)
+        config = schema_links[name]
+        return unless config
+
+        # Derive target schema_slug from link name (e.g., :notes => "note", :company => "company")
+        target_schema_slug = name.to_s.singularize
+
+        @_pending_link_attrs ||= {}
+        @_pending_link_attrs[name] = {
+          config:,
+          attrs: normalize_link_attrs(attrs, config[:cardinality]),
+          target_schema_slug:
+        }
+      end
+
+      def normalize_link_attrs(attrs, cardinality)
+        case attrs
+        when Array
+          attrs
+        when Hash
+          if attrs.keys.all? { |k| k.to_s =~ /\A\d+\z/ }
+            attrs.values
+          elsif cardinality == :many
+            [attrs]
+          else
+            [attrs]
+          end
+        else
+          []
+        end
+      end
+  end
+end

data/app/models/aven/item/schema/builder.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Aven
+  class Item::Schema::Builder
+    attr_reader :fields, :embeds, :links
+
+    def initialize
+      @fields = {}
+      @embeds = {}
+      @links = {}
+    end
+
+    # Scalar fields
+    def string(name, **opts)
+      @fields[name] = { type: :string, **opts }
+    end
+
+    def integer(name, **opts)
+      @fields[name] = { type: :integer, **opts }
+    end
+
+    def boolean(name, **opts)
+      @fields[name] = { type: :boolean, **opts }
+    end
+
+    def date(name, **opts)
+      @fields[name] = { type: :string, format: "date", **opts }
+    end
+
+    def datetime(name, **opts)
+      @fields[name] = { type: :string, format: "date-time", **opts }
+    end
+
+    def array(name, of:, **opts)
+      @fields[name] = { type: :array, items: { type: of }, **opts }
+    end
+
+    # Embeds with inline schema block
+    def embeds_many(name, &block)
+      embed_builder = EmbedBuilder.new
+      embed_builder.instance_eval(&block) if block
+      @embeds[name] = { cardinality: :many, fields: embed_builder.fields }
+    end
+
+    def embeds_one(name, &block)
+      embed_builder = EmbedBuilder.new
+      embed_builder.instance_eval(&block) if block
+      @embeds[name] = { cardinality: :one, fields: embed_builder.fields }
+    end
+
+    # Links to other Items
+    def links_many(name, class_name: "Aven::Item", inverse_of: nil)
+      @links[name] = { cardinality: :many, class_name:, inverse_of: }
+    end
+
+    def links_one(name, class_name: "Aven::Item", inverse_of: nil)
+      @links[name] = { cardinality: :one, class_name:, inverse_of: }
+    end
+
+    # JSON Schema generation
+    def to_json_schema
+      props = {}
+      required = []
+
+      fields.each do |name, config|
+        props[name.to_s] = field_to_json_prop(config)
+        required << name.to_s if config[:required]
+      end
+
+      embeds.each do |name, config|
+        embed_schema = embed_to_json_schema(config[:fields])
+        if config[:cardinality] == :many
+          props[name.to_s] = { "type" => "array", "items" => embed_schema }
+        else
+          props[name.to_s] = embed_schema
+        end
+      end
+
+      { "type" => "object", "properties" => props, "required" => required }
+    end
+
+    private
+
+      def field_to_json_prop(config)
+        prop = { "type" => config[:type].to_s }
+        prop["format"] = config[:format] if config[:format]
+        prop["enum"] = config[:enum] if config[:enum]
+        prop["maxLength"] = config[:max_length] if config[:max_length]
+        prop["minLength"] = config[:min_length] if config[:min_length]
+        prop["items"] = { "type" => config[:items][:type].to_s } if config[:items]
+        prop
+      end
+
+      def embed_to_json_schema(fields)
+        props = {}
+        required = []
+
+        fields.each do |name, config|
+          props[name.to_s] = field_to_json_prop(config)
+          required << name.to_s if config[:required]
+        end
+
+        { "type" => "object", "properties" => props, "required" => required }
+      end
+
+      # Nested builder for embeds
+      class EmbedBuilder
+        attr_reader :fields
+
+        def initialize
+          @fields = {}
+        end
+
+        def string(name, **opts)
+          @fields[name] = { type: :string, **opts }
+        end
+
+        def integer(name, **opts)
+          @fields[name] = { type: :integer, **opts }
+        end
+
+        def boolean(name, **opts)
+          @fields[name] = { type: :boolean, **opts }
+        end
+
+        def date(name, **opts)
+          @fields[name] = { type: :string, format: "date", **opts }
+        end
+
+        def datetime(name, **opts)
+          @fields[name] = { type: :string, format: "date-time", **opts }
+        end
+
+        def array(name, of:, **opts)
+          @fields[name] = { type: :array, items: { type: of }, **opts }
+        end
+      end
+  end
+end

data/app/models/aven/item/schemaed.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module Aven
+  module Item::Schemaed
+    extend ActiveSupport::Concern
+
+    # Runtime schema access - delegates to resolved_schema (code class or DB record)
+    def schema_fields
+      schema_source = resolved_schema
+      return {} unless schema_source
+
+      # Code class has .fields, DB record has .fields_config
+      schema_source.respond_to?(:fields) ? schema_source.fields : schema_source.fields_config
+    end
+
+    def schema_embeds
+      schema_source = resolved_schema
+      return {} unless schema_source
+
+      schema_source.respond_to?(:embeds) ? schema_source.embeds : schema_source.embeds_config
+    end
+
+    def schema_links
+      schema_source = resolved_schema
+      return {} unless schema_source
+
+      schema_source.respond_to?(:links) ? schema_source.links : schema_source.links_config
+    end
+
+    def json_schema
+      resolved_schema&.to_json_schema
+    end
+
+    # Embed accessors
+    def read_embed_many(name)
+      cache_key = "@_embed_cache_#{name}"
+      return instance_variable_get(cache_key) if instance_variable_defined?(cache_key)
+
+      raw = data[name.to_s] || []
+      embeds = raw.map { |attrs| Item::Embed.new(attrs) }
+      instance_variable_set(cache_key, embeds)
+    end
+
+    def write_embed_many(name, value)
+      cache_key = "@_embed_cache_#{name}"
+      remove_instance_variable(cache_key) if instance_variable_defined?(cache_key)
+
+      data[name.to_s] = Array(value).map do |v|
+        v.is_a?(Item::Embed) ? v.to_h : v
+      end
+    end
+
+    def read_embed_one(name)
+      cache_key = "@_embed_cache_#{name}"
+      return instance_variable_get(cache_key) if instance_variable_defined?(cache_key)
+
+      raw = data[name.to_s]
+      embed = raw ? Item::Embed.new(raw) : nil
+      instance_variable_set(cache_key, embed)
+    end
+
+    def write_embed_one(name, value)
+      cache_key = "@_embed_cache_#{name}"
+      remove_instance_variable(cache_key) if instance_variable_defined?(cache_key)
+
+      data[name.to_s] = case value
+      when Item::Embed then value.to_h
+      when Hash then value
+      when nil then nil
+      end
+    end
+
+    def build_embed(name, attrs = {})
+      Item::Embed.new(attrs.merge(id: SecureRandom.uuid))
+    end
+
+    # Link accessors
+    def read_link_many(name)
+      return Aven::Item.none unless persisted?
+
+      Aven::Item.active
+          .joins("INNER JOIN aven_item_links ON aven_item_links.target_id = aven_items.id")
+          .where(aven_item_links: { source_id: id, relation: name.to_s })
+          .order("aven_item_links.position")
+    end
+
+    def read_link_many_ids(name)
+      return [] unless persisted?
+
+      Aven::ItemLink.where(source_id: id, relation: name.to_s)
+              .ordered
+              .pluck(:target_id)
+    end
+
+    def write_link_many_ids(name, ids)
+      @_pending_links ||= {}
+      @_pending_links[name] = Array(ids).reject(&:blank?)
+    end
+
+    def read_link_one(name)
+      return nil unless persisted?
+
+      Aven::Item.active
+          .joins("INNER JOIN aven_item_links ON aven_item_links.target_id = aven_items.id")
+          .where(aven_item_links: { source_id: id, relation: name.to_s })
+          .first
+    end
+
+    def read_link_one_id(name)
+      return nil unless persisted?
+
+      Aven::ItemLink.find_by(source_id: id, relation: name.to_s)&.target_id
+    end
+
+    def write_link_one_id(name, target_id)
+      @_pending_links ||= {}
+      @_pending_links[name] = target_id.presence
+    end
+
+    # Dynamic method handling based on schema_slug
+    def method_missing(method, *args, &block)
+      method_str = method.to_s
+
+      # Setter
+      if method_str.end_with?("=")
+        attr_name = method_str.chomp("=").to_sym
+        return handle_setter(attr_name, args.first) if schema_has_attribute?(attr_name)
+      # Getter
+      elsif schema_has_attribute?(method)
+        return handle_getter(method)
+      end
+
+      super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method_str = method.to_s
+      attr_name = method_str.end_with?("=") ? method_str.chomp("=").to_sym : method
+
+      schema_has_attribute?(attr_name) || super
+    end
+
+    private
+
+      def schema_has_attribute?(name)
+        name_str = name.to_s
+        name_sym = name.to_sym
+
+        # Check for *_ids pattern for links
+        if name_str.end_with?("_ids")
+          base = name_str.chomp("_ids").pluralize.to_sym
+          return schema_links.key?(base)
+        end
+
+        # Check for *_id pattern for links_one
+        if name_str.end_with?("_id")
+          base = name_str.chomp("_id").to_sym
+          return schema_links.key?(base) && schema_links[base][:cardinality] == :one
+        end
+
+        # Check for build_* pattern
+        if name_str.start_with?("build_")
+          base = name_str.delete_prefix("build_")
+          singular_base = base.to_sym
+          plural_base = base.pluralize.to_sym
+          return schema_embeds.key?(singular_base) || schema_embeds.key?(plural_base)
+        end
+
+        # Check for *_attributes= pattern
+        if name_str.end_with?("_attributes")
+          base = name_str.chomp("_attributes").to_sym
+          return schema_embeds.key?(base) || schema_links.key?(base)
+        end
+
+        schema_fields.key?(name_sym) || schema_embeds.key?(name_sym) || schema_links.key?(name_sym)
+      end
+
+      def handle_getter(name)
+        name_str = name.to_s
+        name_sym = name.to_sym
+
+        # Link IDs getter
+        if name_str.end_with?("_ids")
+          base = name_str.chomp("_ids").pluralize.to_sym
+          return read_link_many_ids(base)
+        end
+
+        # Link ID getter
+        if name_str.end_with?("_id")
+          base = name_str.chomp("_id").to_sym
+          return read_link_one_id(base)
+        end
+
+        # Build helper
+        if name_str.start_with?("build_")
+          return build_embed(name_str.delete_prefix("build_"))
+        end
+
+        # Embed getter
+        if schema_embeds.key?(name_sym)
+          config = schema_embeds[name_sym]
+          return config[:cardinality] == :many ? read_embed_many(name_sym) : read_embed_one(name_sym)
+        end
+
+        # Link getter
+        if schema_links.key?(name_sym)
+          config = schema_links[name_sym]
+          return config[:cardinality] == :many ? read_link_many(name_sym) : read_link_one(name_sym)
+        end
+
+        # Field getter
+        data[name_str]
+      end
+
+      def handle_setter(name, value)
+        name_str = name.to_s
+        name_sym = name.to_sym
+
+        # Link IDs setter
+        if name_str.end_with?("_ids")
+          base = name_str.chomp("_ids").pluralize.to_sym
+          return write_link_many_ids(base, value)
+        end
+
+        # Link ID setter
+        if name_str.end_with?("_id")
+          base = name_str.chomp("_id").to_sym
+          return write_link_one_id(base, value)
+        end
+
+        # Attributes setter (nested attributes)
+        if name_str.end_with?("_attributes")
+          base = name_str.chomp("_attributes").to_sym
+          if schema_embeds.key?(base)
+            return process_embed_attributes(base, value)
+          elsif schema_links.key?(base)
+            return process_link_attributes(base, value)
+          end
+          return
+        end
+
+        # Embed setter
+        if schema_embeds.key?(name_sym)
+          config = schema_embeds[name_sym]
+          return config[:cardinality] == :many ? write_embed_many(name_sym, value) : write_embed_one(name_sym, value)
+        end
+
+        # Field setter
+        data[name_str] = value
+      end
+  end
+end

data/app/models/aven/item/schemas/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Aven
+  class Item::Schemas::Base
+    class_attribute :_builder
+
+    class << self
+      def inherited(subclass)
+        super
+        subclass._builder = Item::Schema::Builder.new
+      end
+
+      def slug
+        name.demodulize.underscore
+      end
+
+      def builder
+        _builder
+      end
+
+      # DSL methods delegate to builder
+      def string(name, **opts)
+        _builder.string(name, **opts)
+      end
+
+      def integer(name, **opts)
+        _builder.integer(name, **opts)
+      end
+
+      def boolean(name, **opts)
+        _builder.boolean(name, **opts)
+      end
+
+      def date(name, **opts)
+        _builder.date(name, **opts)
+      end
+
+      def datetime(name, **opts)
+        _builder.datetime(name, **opts)
+      end
+
+      def array(name, of:, **opts)
+        _builder.array(name, of:, **opts)
+      end
+
+      def embeds_many(name, &block)
+        _builder.embeds_many(name, &block)
+      end
+
+      def embeds_one(name, &block)
+        _builder.embeds_one(name, &block)
+      end
+
+      def links_many(name, class_name: "Aven::Item", inverse_of: nil)
+        _builder.links_many(name, class_name:, inverse_of:)
+      end
+
+      def links_one(name, class_name: "Aven::Item", inverse_of: nil)
+        _builder.links_one(name, class_name:, inverse_of:)
+      end
+
+      def fields
+        _builder&.fields || {}
+      end
+
+      def embeds
+        _builder&.embeds || {}
+      end
+
+      def links
+        _builder&.links || {}
+      end
+
+      def to_json_schema
+        _builder&.to_json_schema
+      end
+
+      # Query helpers - delegate to Item scoped by schema_slug
+      def all
+        Aven::Item.by_schema(slug)
+      end
+
+      def where(...)
+        all.where(...)
+      end
+
+      def find(...)
+        all.find(...)
+      end
+
+      def find_by(...)
+        all.find_by(...)
+      end
+
+      def create(attrs = {})
+        Aven::Item.create(attrs.merge(schema_slug: slug))
+      end
+
+      def create!(attrs = {})
+        Aven::Item.create!(attrs.merge(schema_slug: slug))
+      end
+
+      def new(attrs = {})
+        Aven::Item.new(attrs.merge(schema_slug: slug))
+      end
+    end
+  end
+end