activeitem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a08a2b03026d0380bc6232ad035c49ca911bb5ee96c8e7d55de3dd23ebc3dcba
+  data.tar.gz: 1778c6afe64631e5f40ef13b69a761109475befffdea301cb4144a5ea0abc7bb
+SHA512:
+  metadata.gz: c03b044f31d8a843fd37f066a6f5ae25a406165db25541a717e547bee044f20f09f45399dc4beaa133fb696611d86ee0938d09d9e67d3cdb50616e9493005c8b
+  data.tar.gz: 024f823d6e9d76a4e7f9b9a77ac1e9212d213a549e9fc735051e7fdc2c5ac507f28c894aa9d2d209b589a772f5db534063c3e33d7f8db64cc8eefeea02b8955d

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.0.1
+
+- Initial release
+- Core ORM: find, save, create, update, destroy
+- Chainable query builder (Relation) with where, not, limit, order, select
+- Associations: has_many, belongs_to with dependent options
+- Callbacks: before/after save, create, update, destroy, validation
+- Dirty tracking: attribute_changed?, changes, previous_changes
+- Validations: uniqueness, length, numericality, format (via ActiveModel)
+- Transactions: TransactWriteItems and TransactGetItems
+- Pagination: cursor-based with PaginatedResult
+- Composed of: value object aggregation
+- Batch operations: batch_find, batch_write
+- Configurable table naming, logger, and DynamoDB client

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andy Davis
+
+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/README.md

@@ -0,0 +1,112 @@
+# ActiveItem
+
+ActiveRecord-like ORM for AWS DynamoDB.
+
+## Installation
+
+```ruby
+gem 'activeitem'
+```
+
+## Configuration
+
+```ruby
+ActiveItem.configure do |config|
+  config.table_prefix = 'myapp'
+  config.environment = 'production'
+  config.logger = Rails.logger # or any Logger-compatible object
+end
+```
+
+Table names are generated as `{prefix}-{environment}-{model-name-pluralized}`.
+
+## Usage
+
+```ruby
+class User < ActiveItem::Base
+  self.primary_key = :user_id
+
+  attr_accessor :email, :name, :status
+
+  indexes(
+    'EmailIndex' => { partition_key: 'email' },
+    'StatusIndex' => { partition_key: 'status', sort_key: 'createdAt' }
+  )
+
+  validates :email, presence: true
+  validates :email, uniqueness: true
+
+  scope :active, -> { where(status: 'active') }
+
+  before_create :set_defaults
+
+  private
+
+  def set_defaults
+    self.status ||= 'active'
+  end
+end
+```
+
+### CRUD
+
+```ruby
+user = User.create!(email: 'alice@example.com', name: 'Alice')
+user = User.find('user-123')
+user.update(name: 'Alice Smith')
+user.destroy
+```
+
+### Querying
+
+```ruby
+User.where(status: 'active', index: 'StatusIndex')
+User.where(email: 'alice@example.com', index: 'EmailIndex').first
+User.where.not(status: 'deleted')
+User.all.limit(50)
+User.count
+User.exists?('user-123')
+```
+
+### Associations
+
+```ruby
+class Post < ActiveItem::Base
+  belongs_to :user
+  has_many :comments, foreign_key: 'post_id', index: 'PostIndex'
+end
+```
+
+### Transactions
+
+```ruby
+ActiveItem::Base.transaction do |txn|
+  txn.put(new_record)
+  txn.update(existing_record)
+  txn.delete(old_record)
+end
+```
+
+### Pagination
+
+```ruby
+result = Post.where(user_id: id, index: 'UserIndex').page(cursor, per_page: 25)
+result.items          # => [Post, Post, ...]
+result.pagination_metadata # => { next_cursor: "...", has_more: true, per_page: 25 }
+```
+
+### Composed Of (Value Objects)
+
+```ruby
+class Customer < ActiveItem::Base
+  attr_accessor :street, :city, :state, :zip_code
+
+  composed_of :address, class_name: 'Address', mapping: {
+    street: :street, city: :city, state: :state, zip_code: :zip_code
+  }
+end
+```
+
+## License
+
+MIT

data/lib/active_item/associations.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/inflector'
+require_relative 'model_loader'
+
+module ActiveItem
+  module Associations
+    extend ActiveSupport::Concern
+    include ModelLoader
+
+    included do
+      class_attribute :_associations, default: {}
+    end
+
+    def check_dependent_associations
+      self.class._associations.each do |name, config|
+        next unless config[:type] == :has_many && config[:dependent]
+
+        associated_records = send(name)
+        has_records = associated_records.respond_to?(:any?) ? associated_records.any? : false
+
+        next unless has_records
+
+        case config[:dependent]
+        when :restrict_with_exception
+          raise DeleteRestrictionError.new(name)
+        when :restrict_with_error
+          error_message = config[:message] || "Cannot delete #{self.class.name} because dependent #{name} exist"
+          errors.add(:base, error_message)
+          throw(:abort)
+        when :destroy
+          associated_records.each(&:destroy)
+        when :delete_all
+          associated_records.each(&:delete)
+        when :nullify
+          foreign_key = config[:foreign_key]
+          associated_records.each { |record| record.update(foreign_key => nil) }
+        end
+      end
+    end
+
+    class_methods do
+      def has_many(name, scope_or_options = nil, options = {})
+        if scope_or_options.is_a?(Proc)
+          scope = scope_or_options
+        elsif scope_or_options.is_a?(Hash)
+          options = scope_or_options
+          scope = nil
+        else
+          scope = nil
+        end
+
+        association_name = name.to_sym
+        class_name = options[:class_name] || name.to_s.singularize.camelize
+        foreign_key = options[:foreign_key] || "#{self.name.underscore}_id"
+        index_name = options[:index]
+        local_key = options[:primary_key] || primary_key
+
+        self._associations = _associations.merge(
+          association_name => {
+            type: :has_many, class_name: class_name, foreign_key: foreign_key,
+            index: index_name, primary_key: local_key, scope: scope,
+            dependent: options[:dependent], message: options[:message]
+          }
+        )
+
+        define_method(association_name) { load_has_many_association(association_name) }
+
+        define_method(:"#{association_name}_count") do
+          _preloaded_counts.key?(association_name) ? _preloaded_counts[association_name] : send(association_name).length
+        end
+      end
+
+      def belongs_to(name, options = {})
+        association_name = name.to_sym
+        class_name = options[:class_name] || name.to_s.camelize
+        foreign_key = options[:foreign_key] || "#{name}_id"
+        remote_primary_key = options[:primary_key]
+        optional = options.fetch(:optional, false)
+
+        self._associations = _associations.merge(
+          association_name => {
+            type: :belongs_to, class_name: class_name, foreign_key: foreign_key,
+            primary_key: remote_primary_key, optional: optional
+          }
+        )
+
+        foreign_key_sym = foreign_key.to_sym
+        unless method_defined?(foreign_key_sym) || private_method_defined?(foreign_key_sym)
+          attr_accessor foreign_key_sym
+        end
+
+        validates foreign_key_sym, presence: true unless optional
+
+        define_method(association_name) { load_belongs_to_association(association_name) }
+
+        define_method("#{association_name}=") { |record| set_belongs_to_association(association_name, record) }
+
+        default_foreign_key = "#{association_name}_id"
+        if foreign_key.to_s != default_foreign_key
+          define_method(default_foreign_key) { send(foreign_key) }
+          define_method("#{default_foreign_key}=") { |value| send("#{foreign_key}=", value) }
+        end
+      end
+    end
+
+    private
+
+    def load_has_many_association(name)
+      config = self.class._associations[name]
+      return Relation.new(Object, conditions: { _empty: true }) unless config
+
+      if _preloaded_associations.key?(name)
+        return Relation.new(nil, preloaded_records: _preloaded_associations[name], class_name: config[:class_name])
+      end
+
+      local_key_value = send(config[:primary_key])
+      return Relation.new(nil, conditions: { _empty: true }, class_name: config[:class_name]) if local_key_value.nil?
+
+      conditions = { config[:foreign_key].to_sym => local_key_value }
+      relation = Relation.new(nil, conditions: conditions, index_name: config[:index],
+                              class_name: config[:class_name], owner: self)
+
+      if config[:scope]
+        if config[:scope].arity == 0
+          relation.instance_exec(&config[:scope]) || relation
+        else
+          config[:scope].call(relation)
+        end
+      else
+        relation
+      end
+    end
+
+    def load_belongs_to_association(name)
+      config = self.class._associations[name]
+      return nil unless config
+
+      cache_var = :"@_association_cache_#{name}"
+      return instance_variable_get(cache_var) if instance_variable_defined?(cache_var)
+
+      foreign_key_value = send(config[:foreign_key])
+      return nil if foreign_key_value.nil?
+
+      klass = safe_constantize_model(config[:class_name])
+
+      begin
+        record = klass.find(foreign_key_value)
+      rescue ActiveItem::RecordNotFound
+        raise unless config[:optional]
+        record = nil
+      end
+      instance_variable_set(cache_var, record)
+      record
+    end
+
+    def set_belongs_to_association(name, record)
+      config = self.class._associations[name]
+      return unless config
+
+      cache_var = :"@_association_cache_#{name}"
+      instance_variable_set(cache_var, record)
+
+      if record.nil?
+        send("#{config[:foreign_key]}=", nil)
+      else
+        pk = config[:primary_key] || record.class.primary_key
+        send("#{config[:foreign_key]}=", record.send(pk))
+      end
+
+      hook_method = :"after_set_#{name}_association"
+      send(hook_method, record) if respond_to?(hook_method, true)
+    end
+  end
+end