activeitem 0.0.1

data/lib/active_item/composed_of.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveItem
+  module ComposedOf
+    extend ActiveSupport::Concern
+
+    def populate_composed_attributes_from_item(item)
+      self.class.compositions.each do |part_id, config|
+        dynamo_key = self.class.to_dynamo_key(part_id.to_s)
+        vo_class = Object.const_get(config[:class_name])
+
+        if item[dynamo_key].is_a?(Hash)
+          vo = if vo_class.respond_to?(:from_dynamo_map)
+                 vo_class.from_dynamo_map(item[dynamo_key])
+               else
+                 kwargs = {}
+                 config[:mapping].each do |_model_attr, vo_attr|
+                   key = self.class.to_dynamo_key(vo_attr.to_s)
+                   kwargs[vo_attr] = item[dynamo_key][key] || item[dynamo_key][vo_attr.to_s]
+                 end
+                 vo_class.new(**kwargs)
+               end
+
+          instance_variable_set("@_composed_#{part_id}", vo)
+          config[:mapping].each do |model_attr, vo_attr|
+            instance_variable_set("@#{model_attr}", vo.send(vo_attr))
+          end
+        end
+      end
+    end
+
+    private
+
+    def build_dynamodb_item
+      item = super
+
+      self.class.compositions.each do |part_id, config|
+        vo = send(part_id)
+        dynamo_key = self.class.to_dynamo_key(part_id.to_s)
+
+        if vo.nil?
+          item.delete(dynamo_key)
+        elsif vo.respond_to?(:to_dynamo_map)
+          item[dynamo_key] = vo.to_dynamo_map
+        else
+          map = {}
+          config[:mapping].each do |_model_attr, vo_attr|
+            key = self.class.to_dynamo_key(vo_attr.to_s)
+            map[key] = vo.send(vo_attr)
+          end
+          item[dynamo_key] = map.compact
+        end
+
+        config[:mapping].each_key do |model_attr|
+          flat_key = self.class.to_dynamo_key(model_attr.to_s)
+          item.delete(flat_key)
+        end
+      end
+
+      item
+    end
+
+    def perform_update
+      return if changes.empty?
+
+      compositions = self.class.compositions
+      return super if compositions.empty?
+
+      changed_compositions = {}
+      compositions.each do |part_id, config|
+        changed_attrs = config[:mapping].keys.map(&:to_s) & changes.keys
+        changed_compositions[part_id] = config if changed_attrs.any?
+      end
+
+      return super if changed_compositions.empty?
+
+      update_parts = []
+      remove_parts = []
+      attr_values = {}
+      attr_names = {}
+      idx = 0
+
+      composed_flat_keys = compositions.values.flat_map { |c| c[:mapping].keys.map(&:to_s) }.to_set
+
+      changes.each do |field, (_old_val, new_val)|
+        next if composed_flat_keys.include?(field)
+        dynamo_key = self.class.to_dynamo_key(field)
+        if new_val.nil?
+          remove_parts << "#field#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+        else
+          update_parts << "#field#{idx} = :val#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+          attr_values[":val#{idx}"] = new_val
+        end
+        idx += 1
+      end
+
+      changed_compositions.each do |part_id, _config|
+        remove_instance_variable("@_composed_#{part_id}") if instance_variable_defined?("@_composed_#{part_id}")
+        vo = send(part_id)
+        dynamo_key = self.class.to_dynamo_key(part_id.to_s)
+
+        if vo.nil?
+          remove_parts << "#field#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+        else
+          map_value = vo.respond_to?(:to_dynamo_map) ? vo.to_dynamo_map : vo.to_h
+          update_parts << "#field#{idx} = :val#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+          attr_values[":val#{idx}"] = map_value
+        end
+        idx += 1
+      end
+
+      update_parts << 'updatedAt = :updatedAt'
+      attr_values[':updatedAt'] = Time.now.utc.iso8601
+
+      update_expression = "SET #{update_parts.join(', ')}"
+      update_expression += " REMOVE #{remove_parts.join(', ')}" if remove_parts.any?
+
+      params = {
+        table_name: table_name,
+        key: { self.class.primary_key.to_s => id },
+        update_expression: update_expression,
+        expression_attribute_values: attr_values
+      }
+      params[:expression_attribute_names] = attr_names if attr_names.any?
+
+      dynamodb.update_item(params)
+    end
+
+    module ClassMethods
+      def compositions
+        @_compositions ||= {}
+      end
+
+      def composed_of(part_id, options = {})
+        class_name  = options[:class_name] || part_id.to_s.camelize
+        mapping     = options[:mapping] || {}
+        allow_nil   = options.fetch(:allow_nil, true)
+        constructor = options.fetch(:constructor, :new)
+        converter   = options[:converter]
+
+        compositions[part_id] = { class_name: class_name, mapping: mapping, allow_nil: allow_nil,
+                                  constructor: constructor, converter: converter }
+
+        define_method(part_id) do
+          ivar = "@_composed_#{part_id}"
+          return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+
+          vo_class = Object.const_get(class_name)
+          values = mapping.map { |model_attr, _vo_attr| send(model_attr) }
+
+          if allow_nil && values.all? { |v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+            instance_variable_set(ivar, nil)
+            return nil
+          end
+
+          vo = if constructor.is_a?(Proc)
+                 constructor.call(*values)
+               else
+                 kwargs = {}
+                 mapping.each { |model_attr, vo_attr| kwargs[vo_attr] = send(model_attr) }
+                 vo_class.send(constructor, **kwargs)
+               end
+
+          instance_variable_set(ivar, vo)
+        end
+
+        define_method("#{part_id}=") do |value|
+          ivar = "@_composed_#{part_id}"
+
+          if value.nil?
+            mapping.each_key { |model_attr| send("#{model_attr}=", nil) }
+            instance_variable_set(ivar, nil)
+          elsif value.is_a?(Object.const_get(class_name))
+            mapping.each { |model_attr, vo_attr| send("#{model_attr}=", value.send(vo_attr)) }
+            instance_variable_set(ivar, value)
+          elsif converter
+            converted = converter.is_a?(Proc) ? converter.call(value) : Object.const_get(class_name).send(converter, value)
+            send("#{part_id}=", converted)
+          elsif value.is_a?(Hash)
+            vo = Object.const_get(class_name).new(**value.transform_keys(&:to_sym))
+            send("#{part_id}=", vo)
+          else
+            raise ArgumentError, "Cannot assign #{value.class} to #{part_id}. Expected #{class_name}, Hash, or nil."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_item/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module ActiveItem
+  class Configuration
+    attr_accessor :logger, :table_prefix, :environment
+
+    def initialize
+      @logger = NullLogger.new
+      @table_prefix = nil
+      @environment = nil
+    end
+
+    # Generates table name from model class name using configured prefix/env
+    # Pattern: {prefix}-{env}-{model-name-pluralized}
+    # If no prefix configured, just uses the model name pluralized+dasherized
+    def table_name_for(class_name)
+      base = class_name.underscore.dasherize.pluralize
+      parts = [table_prefix, environment, base].compact
+      parts.join('-')
+    end
+  end
+end

data/lib/active_item/database_helpers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module ActiveItem
+  module DatabaseHelpers
+    def get(key)
+      response = dynamodb.get_item(table_name: table_name, key: key)
+      response.item
+    rescue Aws::DynamoDB::Errors::AccessDeniedException => e
+      raise_access_denied('GetItem', e)
+    end
+
+    def put(item)
+      dynamodb.put_item(table_name: table_name, item: item)
+    rescue Aws::DynamoDB::Errors::AccessDeniedException => e
+      raise_access_denied('PutItem', e)
+    end
+
+    def delete(key)
+      dynamodb.delete_item(table_name: table_name, key: key)
+    rescue Aws::DynamoDB::Errors::AccessDeniedException => e
+      raise_access_denied('DeleteItem', e)
+    end
+
+    def exists?(key)
+      !get(key).nil?
+    end
+
+    def query(key_condition_expression:, expression_attribute_values:, **options)
+      query_params = {
+        table_name: table_name,
+        key_condition_expression: key_condition_expression,
+        expression_attribute_values: expression_attribute_values
+      }.merge(options)
+
+      response = dynamodb.query(query_params)
+      response.items
+    rescue Aws::DynamoDB::Errors::AccessDeniedException => e
+      raise_access_denied('Query', e)
+    end
+
+    def scan(limit: nil, filter_expression: nil, expression_attribute_names: nil, expression_attribute_values: nil, projection_expression: nil)
+      params = { table_name: table_name }
+      params[:limit] = limit if limit
+      params[:filter_expression] = filter_expression if filter_expression
+      params[:expression_attribute_names] = expression_attribute_names if expression_attribute_names
+      params[:expression_attribute_values] = expression_attribute_values if expression_attribute_values
+      params[:projection_expression] = projection_expression if projection_expression
+
+      items = []
+      seen_ids = Set.new
+      last_evaluated_key = nil
+
+      loop do
+        params[:exclusive_start_key] = last_evaluated_key if last_evaluated_key
+        response = dynamodb.scan(params)
+
+        response.items.each do |item|
+          pk_value = item[primary_key.to_s]
+          unless seen_ids.include?(pk_value)
+            seen_ids.add(pk_value)
+            items << item
+          end
+        end
+
+        last_evaluated_key = response.last_evaluated_key
+        break unless last_evaluated_key
+        break if limit && items.length >= limit
+      end
+
+      items
+    rescue Aws::DynamoDB::Errors::AccessDeniedException => e
+      raise_access_denied('Scan', e)
+    end
+
+    private
+
+    def raise_access_denied(operation, original_error)
+      raise ActiveItem::AccessDeniedError.new(model_name: name, table: table_name,
+                                                operation: operation, original_error: original_error)
+    end
+  end
+end

data/lib/active_item/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveItem
+  class RecordNotFound < StandardError; end
+  class TransactionError < StandardError; end
+
+  class AccessDeniedError < StandardError
+    attr_reader :model_name, :table, :operation, :original_error
+
+    def initialize(model_name:, table:, operation:, original_error:)
+      @model_name = model_name
+      @table = table
+      @operation = operation
+      @original_error = original_error
+      super("#{model_name} is not allowed to #{operation} on #{table}. " \
+            "Ensure the IAM role has access to this table.")
+    end
+  end
+
+  class DeleteRestrictionError < StandardError
+    attr_reader :association_name
+
+    def initialize(association_name)
+      @association_name = association_name
+      super("Cannot delete record because dependent #{association_name} exist")
+    end
+  end
+end

data/lib/active_item/logging.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveItem
+  # Minimal logger that discards all output. Used as default when no logger configured.
+  class NullLogger
+    def info(*); end
+    def warn(*); end
+    def error(*); end
+    def debug(*); end
+  end
+
+  module Logging
+    private
+
+    def dynamo_logger
+      ActiveItem.logger
+    end
+  end
+end

data/lib/active_item/model_loader.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module ActiveItem
+  module ModelLoader
+    def safe_constantize_model(class_name)
+      return class_name.constantize if Object.const_defined?(class_name)
+
+      file_name = class_name.underscore
+      # Try common model paths
+      ['.', 'models', 'app/models'].each do |dir|
+        path = File.join(dir, "#{file_name}.rb")
+        if File.exist?(path)
+          require path
+          break
+        end
+      end
+
+      class_name.constantize
+    end
+  end
+end

data/lib/active_item/pagination.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActiveItem
+  module Pagination
+    DEFAULT_PER_PAGE = 25
+    MAX_PER_PAGE = 100
+
+    def self.paginate_array(items, cursor = nil, per_page: DEFAULT_PER_PAGE)
+      per_page = [[per_page.to_i, 1].max, MAX_PER_PAGE].min
+
+      if cursor && !cursor.empty?
+        cursor_time, cursor_id = cursor.split('|', 2)
+        items = items.drop_while { |i| ([(i.created_at || ''), i.id] <=> [cursor_time, cursor_id]) >= 0 }
+      end
+
+      page_items = items.first(per_page)
+      has_more = items.length > per_page
+      last = page_items.last
+      next_cursor = has_more && last ? "#{last.created_at}|#{last.id}" : nil
+
+      PaginatedResult.new(items: page_items, next_cursor: next_cursor, per_page: per_page)
+    end
+
+    class PaginatedResult
+      include Enumerable
+
+      attr_reader :items, :next_cursor, :per_page
+
+      def initialize(items:, next_cursor:, per_page:)
+        @items = items
+        @next_cursor = next_cursor
+        @per_page = per_page
+      end
+
+      def has_more?
+        !next_cursor.nil?
+      end
+
+      def pagination_metadata
+        { next_cursor: next_cursor, has_more: has_more?, per_page: per_page }
+      end
+
+      def each(&block) = items.each(&block)
+      def length = items.length
+      alias_method :size, :length
+      alias_method :count, :length
+      def empty? = items.empty?
+      def to_a = items
+    end
+  end
+end