airctiverecord 0.2.0

data/lib/airctiverecord/base.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  class Base < Norairrecord::Table
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+    include AirctiveRecord::Validations
+    include AirctiveRecord::Callbacks
+    include AirctiveRecord::AttributeMethods
+    include AirctiveRecord::Associations
+    include AirctiveRecord::Scoping
+
+    class << self
+      def column_names
+        @column_names ||= []
+      end
+
+      def attribute(name, airtable_field_name = nil, **options)
+        column_names << name.to_s unless column_names.include?(name.to_s)
+        field(name, airtable_field_name, **options)
+      end
+
+      # each model gets its own Relation class
+      def relation_class
+        @relation_class ||= Class.new(AirctiveRecord::Relation)
+      end
+
+      def relation_class_name
+        "#{name}::Relation"
+      end
+    end
+
+    def initialize(attributes = {}, **kwargs)
+      # Extract id and created_at if present
+      id = kwargs.delete(:id)
+      created_at = kwargs.delete(:created_at)
+      
+      # Merge positional hash and kwargs to handle both styles
+      all_attrs = attributes.is_a?(Hash) ? attributes.merge(kwargs) : kwargs
+      
+      # Norairrecord::Table expects field names as STRING keys
+      # We need to convert Ruby attribute names to Airtable field names
+      mapped_attrs = {}
+      all_attrs.each do |key, value|
+        field_name = self.class.field_mappings[key.to_s] || key.to_s
+        mapped_attrs[field_name.to_s] = value # Ensure string keys
+      end
+      
+      # Call norairrecord's initialize properly
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.0.0")
+        if mapped_attrs.empty?
+          super(id: id, created_at: created_at)
+        else
+          super(mapped_attrs, id: id, created_at: created_at)
+        end
+      else
+        super(mapped_attrs, id: id, created_at: created_at)
+      end
+      
+      clear_changes_information
+    end
+
+    def assign_attributes(attrs)
+      self.attributes = attrs
+    end
+
+    def serializable_fields
+      # exclude readonly fields from serialization
+      fields.reject { |k, v| self.class.readonly_fields.include?(k) }
+    end
+
+    def save(**options)
+      return false unless valid?
+      
+      begin
+        run_callbacks :save do
+          if new_record?
+            run_callbacks :create do
+              super(**options)
+            end
+          else
+            run_callbacks :update do
+              super(**options)
+            end
+          end
+        end
+        changes_applied
+        true
+      rescue => e
+        false
+      end
+    end
+
+    def save!(**options)
+      raise RecordInvalid, errors.full_messages.join(", ") unless valid?
+      save(**options) || raise(RecordNotSaved, "Failed to save record")
+    end
+
+    def update(attributes)
+      attributes.each { |key, value| send("#{key}=", value) }
+      save
+    end
+
+    def update!(attributes)
+      attributes.each { |key, value| send("#{key}=", value) }
+      save!
+    end
+
+    def reload
+      return self if new_record?
+      reloaded = self.class.find(id)
+      @fields = reloaded.fields
+      @created_at = reloaded.created_at
+      clear_changes_information
+      self
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def to_param
+      id
+    end
+
+    def to_key
+      persisted? ? [id] : nil
+    end
+
+    def to_model
+      self
+    end
+  end
+end

data/lib/airctiverecord/callbacks.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+      define_model_callbacks :initialize, only: :after
+    end
+
+    def destroy
+      run_callbacks :destroy do
+        super
+      end
+    end
+  end
+end

data/lib/airctiverecord/relation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  # Base Relation class - models create subclasses of this
+  # Each model's relation knows about that model's field mappings and scopes
+  class Relation < Airrel::Relation
+    # override where to apply field mappings when building formulas from hashes
+    def where(conditions)
+      if conditions.is_a?(Hash)
+        # build formula with field mappings
+        formula = Airrel::FormulaBuilder.hash_to_formula(conditions, klass.field_mappings)
+        super(formula)
+      else
+        super
+      end
+    end
+
+    # override to use field mappings when building airtable params
+    def to_airtable_params
+      params = {}
+      
+      # filter
+      if @where_clause.any?
+        params[:filter] = @where_clause.to_airtable_formula
+      end
+
+      # sort - use field mappings
+      if @order_values.any?
+        params[:sort] = @order_values.map do |field, direction|
+          mapped_field = klass.field_mappings[field.to_s] || field.to_s
+          { field: mapped_field, direction: direction.to_s }
+        end
+      end
+
+      # limit
+      params[:max_records] = @limit_value if @limit_value
+      
+      # offset
+      params[:offset] = @offset_value if @offset_value
+
+      params
+    end
+
+    # spawn returns a new instance of the same Relation subclass
+    def spawn
+      self.class.new(klass).tap do |relation|
+        relation.instance_variable_set(:@where_clause, @where_clause)
+        relation.instance_variable_set(:@order_values, @order_values.dup)
+        relation.instance_variable_set(:@limit_value, @limit_value)
+        relation.instance_variable_set(:@offset_value, @offset_value)
+      end
+    end
+  end
+end

data/lib/airctiverecord/scoping.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # returns a chainable Relation object (model-specific!)
+      def all
+        relation_class.new(self)
+      end
+
+      # scopes are defined on the model's specific Relation class
+      def scope(name, body)
+        unless body.respond_to?(:call)
+          raise ArgumentError, "The scope body needs to be callable."
+        end
+
+        # define on the class
+        singleton_class.send(:define_method, name) do |*args|
+          all.public_send(name, *args)
+        end
+        
+        # define on this model's Relation class
+        relation_class.send(:define_method, name) do |*args|
+          instance_exec(*args, &body)
+        end
+      end
+
+      # delegate finder methods to all
+      def where(conditions)
+        all.where(conditions)
+      end
+
+      def order(*args)
+        all.order(*args)
+      end
+
+      def limit(value)
+        all.limit(value)
+      end
+
+      def offset(value)
+        all.offset(value)
+      end
+
+      def find_by(conditions)
+        all.find_by(conditions)
+      end
+
+      def find_by!(conditions)
+        all.find_by!(conditions)
+      end
+
+      def first(limit = nil)
+        all.first(limit)
+      end
+
+      def last(limit = nil)
+        all.last(limit)
+      end
+
+      def count
+        all.count
+      end
+    end
+  end
+end

data/lib/airctiverecord/validations.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations
+
+      define_model_callbacks :validation
+    end
+
+    def valid?(context = nil)
+      run_callbacks :validation do
+        super
+      end
+    end
+
+    def save(**options)
+      return false unless valid?
+      super
+    end
+  end
+end

data/lib/airctiverecord/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AirctiveRecord
+  VERSION = "0.2.0"
+end

data/lib/airctiverecord.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "airctiverecord/version"
+require "norairrecord"
+require "active_model"
+require "airrel"
+
+module AirctiveRecord
+  class Error < StandardError; end
+  class RecordInvalid < Error; end
+  class RecordNotSaved < Error; end
+
+  autoload :Base, "airctiverecord/base"
+  autoload :Callbacks, "airctiverecord/callbacks"
+  autoload :Validations, "airctiverecord/validations"
+  autoload :AttributeMethods, "airctiverecord/attribute_methods"
+  autoload :Associations, "airctiverecord/associations"
+  autoload :Scoping, "airctiverecord/scoping"
+  autoload :Relation, "airctiverecord/relation"
+end

data/sig/airctiverecord.rbs

@@ -0,0 +1,4 @@
+module Airctiverecord
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: airctiverecord
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- 24c02
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: norairrecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: airrel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Provides a familiar ActiveRecord-like interface for Airtable, built on
+  top of norairrecord with validations, callbacks, and associations.
+email:
+- 163450896+24c02@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".idea/airctiverecord.iml"
+- ".idea/modules.xml"
+- ".idea/vcs.xml"
+- ".idea/workspace.xml"
+- README.md
+- Rakefile
+- examples/associations_example.rb
+- examples/basic_usage.rb
+- examples/boolean_fields.rb
+- examples/chainable_queries.rb
+- examples/field_mapping_example.rb
+- examples/readonly_fields.rb
+- examples/scope_isolation.rb
+- lib/airctiverecord.rb
+- lib/airctiverecord/associations.rb
+- lib/airctiverecord/attribute_methods.rb
+- lib/airctiverecord/base.rb
+- lib/airctiverecord/callbacks.rb
+- lib/airctiverecord/relation.rb
+- lib/airctiverecord/scoping.rb
+- lib/airctiverecord/validations.rb
+- lib/airctiverecord/version.rb
+- sig/airctiverecord.rbs
+homepage: https://github.com/24c02/airctiverecord
+licenses: []
+metadata:
+  homepage_uri: https://github.com/24c02/airctiverecord
+  source_code_uri: https://github.com/24c02/airctiverecord
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: ActiveRecord/ActiveModel compatible API for Airtable via norairrecord
+test_files: []