harmonia 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6855db28daa85553fa8479d6dd6217c43ae5c008be01c0b5f92b3154ce183f9c
-  data.tar.gz: 9b44c5dd79d2a5626053541bcc0a869025e37ecee53c97018eae853a4004d440
+  metadata.gz: ba24e3fb10ef3510c855bda693d015d4a0b158f0f076af681389d6a26dac6c9e
+  data.tar.gz: 69b3c0a459c92772cc179e6e5584ab38762e6e9dab1898d1787b27aaa9640634
 SHA512:
-  metadata.gz: 03056f3bafcbae9a2b69251fe7de63af424fe8bc216c5f18c228b390f47a6baaef8f041b9f1f66ed51f0f0be8ccf1c6e5653649ff55312be10feca45cf71f0c4
-  data.tar.gz: bf9bde1fd412e5af7b04a5e583fef2441e12ffb20bd55822d33e41f8bfa9e59afce719e5435d6732ee9885492aca376321e9028224c436d6004af7f726337255
+  metadata.gz: 3f940e8b3bca9c1ce1cca522051de2af62a0c9b82b4bab54e0001cef86bab7638086408f66bc6e1eaf76d90f090403871310c750070d534668a187fbadb0f454
+  data.tar.gz: faeb5432593d35938dac873e4aca8240cabcbac7ceb5f902f9756d121f34d00d9abf200f04e66a5d3232a9c1d1f42038c86935e0d07b32103871238afd56f55d

data/README.md

@@ -169,14 +169,14 @@ class ProductSyncer
     @total_create_required = filemaker_records.length
 
     existing_ids = Product.pluck(:filemaker_id)
-    filemaker_records.reject { |record| existing_ids.include?(record.record_id) }
+    filemaker_records.reject { |record| existing_ids.include?(record.id) }
   end
 
   def records_to_update
     filemaker_records = Trophonius::Product.all
 
     records_needing_update = filemaker_records.select { |fm_record|
-      pg_record = Product.find_by(filemaker_id: fm_record.record_id)
+      pg_record = Product.find_by(filemaker_id: fm_record.id)
       pg_record && needs_update?(fm_record, pg_record)
     }
 
@@ -185,7 +185,7 @@ class ProductSyncer
   end
 
   def records_to_delete
-    filemaker_ids = Trophonius::Product.all.map(&:record_id)
+    filemaker_ids = Trophonius::Product.all.map(&:id)
     Product.where.not(filemaker_id: filemaker_ids).pluck(:id)
   end
 
@@ -393,7 +393,7 @@ module Trophonius
     # Converts FileMaker record to PostgreSQL attributes
     def self.to_pg(record)
       {
-        filemaker_id: record.record_id,
+        filemaker_id: record.id,
         name: record.field_data['ProductName'],
         price: record.field_data['Price'].to_f,
         # ... map other fields
@@ -432,8 +432,8 @@ add_index :products, :filemaker_id, unique: true
 
 This column serves as the bridge between your ActiveRecord records and FileMaker records:
 
-- **FileMaker to ActiveRecord**: Stores the FileMaker `record_id` to identify which FileMaker record corresponds to each Rails record
-- **ActiveRecord to FileMaker**: Can store the FileMaker `record_id` after creation, or you can use a separate field in FileMaker (like `PostgreSQLID`) to maintain the relationship
+- **FileMaker to ActiveRecord**: Stores the FileMaker `id` to identify which FileMaker record corresponds to each Rails record
+- **ActiveRecord to FileMaker**: Can store the FileMaker `id` after creation, or you can use a separate field in FileMaker (like `PostgreSQLID`) to maintain the relationship
 
 **Important Notes**:
 - The column is indexed with a unique constraint for performance and data integrity
@@ -601,15 +601,15 @@ RSpec.describe ProductSyncer do
     it 'returns records not in PostgreSQL' do
       # Mock FileMaker records
       allow(Trophonius::Product).to receive(:all).and_return([
-        double(record_id: 1),
-        double(record_id: 2)
+        double(id: 1),
+        double(id: 2)
       ])
 
       # Mock existing PostgreSQL records
       allow(Product).to receive(:pluck).with(:filemaker_id).and_return([1])
 
       result = syncer.send(:records_to_create)
-      expect(result.map(&:record_id)).to eq([2])
+      expect(result.map(&:id)).to eq([2])
     end
   end
 end

data/lib/generators/harmonia/install_generator.rb

@@ -23,10 +23,22 @@ module Harmonia
         copy_file "harmonia_sync.rb", "app/models/harmonia/sync.rb"
       end
 
+      def copy_concerns
+        copy_file "concerns/sync_loggable.rb",            "app/syncers/concerns/sync_loggable.rb"
+        copy_file "concerns/sync_retryable.rb",           "app/syncers/concerns/sync_retryable.rb"
+        copy_file "concerns/photo_syncable.rb",           "app/syncers/concerns/photo_syncable.rb"
+        copy_file "concerns/related_model_validation.rb", "app/syncers/concerns/related_model_validation.rb"
+        copy_file "concerns/related_model_resolver.rb",   "app/syncers/concerns/related_model_resolver.rb"
+      end
+
       def generate_migration
         migration_template "create_harmonia_syncs.rb", "db/migrate/create_harmonia_syncs.rb"
       end
 
+      def generate_server_id_migration
+        migration_template "add_server_id_to_harmonia_syncs.rb", "db/migrate/add_server_id_to_harmonia_syncs.rb"
+      end
+
       def generate_failed_ids_migration
         migration_template "add_failed_ids_to_harmonia_syncs.rb", "db/migrate/add_failed_ids_to_harmonia_syncs.rb"
       end
@@ -43,24 +55,28 @@ module Harmonia
           - config/initializers/trophonius_model_extension.rb
           - app/models/application_record.rb (with to_fm extension)
           - app/models/harmonia/sync.rb
+          - app/syncers/concerns/sync_loggable.rb
+          - app/syncers/concerns/sync_retryable.rb
+          - app/syncers/concerns/photo_syncable.rb
+          - app/syncers/concerns/related_model_validation.rb
+          - app/syncers/concerns/related_model_resolver.rb
           - db/migrate/..._create_harmonia_syncs.rb
+          - db/migrate/..._add_server_id_to_harmonia_syncs.rb
           - db/migrate/..._add_failed_ids_to_harmonia_syncs.rb
 
           Next steps:
           1. Run migrations: rails db:migrate
           2. Update database_connector.rb with your FileMaker database name
           3. Add FileMaker credentials to Rails credentials
-          4. Replace all instances of YourTrophoniusModel with your actual model names
-          5. Generate syncers:
-             - rails generate harmonia:sync ModelName (FileMaker -> ActiveRecord)
-             - rails generate harmonia:reverse_sync ModelName (ActiveRecord -> FileMaker)
+          4. Generate syncers:
+             - rails generate harmonia:sync ModelName    (FileMaker -> ActiveRecord)
+             - rails generate harmonia:reverse_sync ModelName  (ActiveRecord -> FileMaker)
 
         README
 
         say readme_content, :green if behavior == :invoke
       end
 
-      # Required for migration_template to work
       def self.next_migration_number(dirname)
         current = Time.now.utc.strftime("%Y%m%d%H%M%S")
 

data/lib/generators/harmonia/reverse_sync_generator.rb

@@ -34,7 +34,7 @@ module Harmonia
                 task #{task_name}: :environment do
                   dbc = DatabaseConnector.new
 
-                  syncer = #{class_name}Syncer.new(dbc)
+                  syncer = #{class_name}ToFileMakerSyncer.new(dbc)
                   syncer.run
                 end
             TASK
@@ -61,7 +61,10 @@ module Harmonia
 
               desc 'sync #{table_name} from ActiveRecord to FileMaker'
               task #{task_name}: :environment do
-                #{class_name}ToFileMakerSyncer.new.sync
+                dbc = DatabaseConnector.new
+
+                syncer = #{class_name}ToFileMakerSyncer.new(dbc)
+                syncer.run
               end
           TASK
 

data/lib/generators/harmonia/sync_generator.rb

@@ -32,7 +32,11 @@ module Harmonia
 
                 desc 'sync #{table_name} from FileMaker to ActiveRecord'
                 task #{task_name}: :environment do
-                  #{class_name}Syncer.new.sync
+                  dbc = DatabaseConnector.new
+                  server_id = ENV.fetch('SERVER_ID', nil)&.to_i
+
+                  syncer = #{class_name}Syncer.new(dbc, server_id)
+                  syncer.run
                 end
             TASK
 
@@ -59,8 +63,9 @@ module Harmonia
               desc 'sync #{table_name} from FileMaker to ActiveRecord'
               task #{task_name}: :environment do
                 dbc = DatabaseConnector.new
+                server_id = ENV.fetch('SERVER_ID', nil)&.to_i
 
-                syncer = #{class_name}Syncer.new(dbc)
+                syncer = #{class_name}Syncer.new(dbc, server_id)
                 syncer.run
               end
           TASK

data/lib/generators/harmonia/templates/activerecord_to_filemaker_syncer_template.rb

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
 class <%= class_name %>ToFileMakerSyncer
+  include SyncLoggable
+
   attr_accessor :database_connector
 
   def initialize(database_connector)
     @database_connector = database_connector
-    @last_synced_on = Harmonia::Sync.last_sync_for('<%= table_name %>', 'ActiveRecord to FileMaker')&.ran_on || (Time.now - 15.years)
+    @last_synced_on = Harmonia::Sync.last_sync_for('<%= table_name %>', 'ActiveRecord to FileMaker', nil)&.ran_on || (Time.now - 15.years)
+    @failed_fm_ids = {}
+    @failed_pg_ids = {}
   end
 
-  # Main sync method
-  # Executes the sync process for <%= class_name %> records to FileMaker
   def run
     raise StandardError, 'No database connector set' if @database_connector.blank?
 
     sync_record = create_sync_record
+    @sync_started_at = Time.now
+    log_sync_start(table: '<%= table_name %>', direction: 'ActiveRecord to FileMaker')
 
-    @database_connector.open_database do
-      sync_record.start!
-      sync_records(sync_record)
-    end
+    sync_record.start!
+    sync_records(sync_record)
   rescue StandardError => e
-    sync_record&.fail!(e.message)
+    log_sync_error(table: '<%= table_name %>', direction: 'ActiveRecord to FileMaker', error: e)
+    sync_record&.fail!(e.message, failed_fm_ids: @failed_fm_ids, failed_pg_ids: @failed_pg_ids)
     raise
   end
 
@@ -31,57 +34,55 @@ class <%= class_name %>ToFileMakerSyncer
     created_count = create_records
     delete_records
 
-    total_synced = created_count + updated_count
+    total_synced   = created_count + updated_count
     total_required = (@total_create_required || 0) + (@total_update_required || 0)
 
+    log_sync_plan(
+      table: '<%= table_name %>', direction: 'ActiveRecord to FileMaker',
+      to_create: @total_create_required || 0,
+      to_update: @total_update_required || 0,
+      to_delete: 0
+    )
+
     sync_record.finish!(
-      records_synced: total_synced,
-      records_required: total_required
+      records_synced:   total_synced,
+      records_required: total_required,
+      failed_fm_ids:    @failed_fm_ids,
+      failed_pg_ids:    @failed_pg_ids
+    )
+
+    log_sync_finish(
+      table: '<%= table_name %>', direction: 'ActiveRecord to FileMaker',
+      created: created_count, updated: updated_count, deleted: 0,
+      failed_fm: @failed_fm_ids.size, failed_pg: @failed_pg_ids.size,
+      duration: Time.now - @sync_started_at
     )
   end
 
-  # Returns an array of ActiveRecord records that need to be created in FileMaker
-  # Use <%= class_name %>.to_fm(record) to convert to FileMaker attributes
-  # Set @total_create_required to the total number of records that should exist after creation
-  # @return [Array<<%= class_name %>>] Array of ActiveRecord records
+  # Returns ActiveRecord records that need to be created in FileMaker (no filemaker_id yet).
+  # Set @total_create_required to the count.
   def records_to_create
-    # TODO: Implement logic to fetch records from PostgreSQL that need to be created in FileMaker
-    # Example:
-    # pg_records = <%= class_name %>.all
-    # @total_create_required = pg_records.length
-    # existing_ids = YourTrophoniusModel.all.map { |r| r.field_data['PostgreSQLID'] }
-    # pg_records.reject { |record| existing_ids.include?(record.id.to_s) }
+    # TODO: implement
+    # pg_records = <%= class_name %>.where(filemaker_id: nil, ...)
+    # @total_create_required = pg_records.count
+    # pg_records
     @total_create_required = 0
     []
   end
 
-  # Returns an array of ActiveRecord records that need to be updated in FileMaker
-  # Use <%= class_name %>.to_fm(record) to convert to FileMaker attributes
-  # Set @total_update_required to the total number of records that should be updated
-  # @return [Array<<%= class_name %>>] Array of ActiveRecord records
+  # Returns ActiveRecord records that need to be updated in FileMaker.
+  # Set @total_update_required to the count.
   def records_to_update
-    # TODO: Implement logic to fetch records from PostgreSQL that need to be updated in FileMaker
-    # Example:
-    # pg_records = <%= class_name %>.where('updated_at > ?', 1.hour.ago)
-    # records_needing_update = pg_records.select { |pg_record|
-    #   fm_record = find_filemaker_record(pg_record)
-    #   fm_record && needs_update?(pg_record, fm_record)
-    # }
-    # @total_update_required = records_needing_update.length
-    # records_needing_update
+    # TODO: implement
+    # pg_records = <%= class_name %>.where('updated_at > ?', @last_synced_on).where.not(filemaker_id: nil)
+    # @total_update_required = pg_records.count
+    # pg_records
     @total_update_required = 0
     []
   end
 
-  # Returns an array of FileMaker record IDs that need to be deleted
-  # @return [Array] Array of FileMaker record IDs
+  # Returns FileMaker record IDs that should be deleted.
   def records_to_delete
-    # TODO: Implement logic to determine which FileMaker records should be deleted
-    # Example:
-    # pg_ids = <%= class_name %>.pluck(:id).map(&:to_s)
-    # YourTrophoniusModel.all.select { |fm_record|
-    #   !pg_ids.include?(fm_record.field_data['PostgreSQLID'])
-    # }.map(&:record_id)
     []
   end
 
@@ -89,71 +90,71 @@ class <%= class_name %>ToFileMakerSyncer
     records = records_to_create
     return 0 if records.empty?
 
-    records.each do |pg_record|
-      fm_attributes = pg_record.to_fm
-      YourTrophoniusModel.create(fm_attributes)
+    success_count = 0
+    @database_connector.open_database do
+      records.each do |pg_record|
+        fm_attributes = pg_record.to_fm.compact_blank
+        fm_record = FileMaker::<%= class_name %>.create(fm_attributes)
+        pg_record.update!(filemaker_id: fm_record.id)
+        success_count += 1
+      rescue StandardError => e
+        @failed_pg_ids[pg_record.id.to_s] = e.message
+        log_create_error(id: pg_record.id, id_type: :pg, error: e)
+      end
     end
-
-    records.size
+    success_count
   end
 
   def update_records
     records = records_to_update
     return 0 if records.empty?
 
-    records.each do |pg_record|
-      fm_attributes = pg_record.to_fm
-
-      # Find the FileMaker record by PostgreSQL ID or other unique identifier
-      fm_record = find_filemaker_record(pg_record)
-      next unless fm_record
-
-      fm_record.update(fm_attributes)
+    success_count = 0
+    @database_connector.open_database do
+      records.each do |pg_record|
+        fm_record = find_filemaker_record(pg_record)
+        next unless fm_record
+
+        fm_record.update(pg_record.to_fm.compact_blank)
+        success_count += 1
+      rescue StandardError => e
+        @failed_pg_ids[pg_record.id.to_s] = e.message
+        log_update_error(id: pg_record.id, id_type: :pg, error: e)
+      end
     end
-
-    records.size
+    success_count
   end
 
   def delete_records
-    record_ids = records_to_delete
-    return if record_ids.empty?
-
-    record_ids.each do |record_id|
-      fm_record = YourTrophoniusModel.find(record_id)
-      fm_record.destroy
-    rescue Trophonius::RecordNotFoundError
-      # Record already deleted, skip
-      next
+    ids = records_to_delete
+    return if ids.empty?
+
+    @database_connector.open_database do
+      ids.each do |id|
+        FileMaker::<%= class_name %>.where(id:).first&.destroy
+      rescue Trophonius::RecordNotFoundError
+        next
+      end
     end
   end
 
-  # Helper method to find a FileMaker record based on a PostgreSQL record
-  # @param pg_record [ActiveRecord::Base] The PostgreSQL record
-  # @return [Trophonius::Model, nil] The corresponding FileMaker record or nil
+  # Find the FileMaker record corresponding to a PostgreSQL record.
   def find_filemaker_record(pg_record)
-    # TODO: Implement logic to find the corresponding FileMaker record
-    # Example:
-    # YourTrophoniusModel.find_by_field('PostgreSQLID', pg_record.id.to_s)
-    nil
+    return nil if pg_record.filemaker_id.blank?
+
+    FileMaker::<%= class_name %>.where(id: pg_record.filemaker_id).first
   end
 
-  # Determine if a FileMaker record needs to be updated based on PostgreSQL record
-  # @param pg_record [ActiveRecord::Base] The PostgreSQL record
-  # @param fm_record [Trophonius::Model] The FileMaker record
-  # @return [Boolean] true if update is needed
   def needs_update?(pg_record, fm_record)
-    # TODO: Implement your comparison logic
-    # Example:
-    # fm_attributes = pg_record.to_fm
-    # fm_attributes.any? { |key, value| fm_record.field_data[key.to_s] != value }
+    # TODO: implement comparison logic
     true
   end
 
   def create_sync_record
     Harmonia::Sync.create!(
-      table: '<%= table_name %>',
-      ran_on: Time.now,
-      status: 'pending',
+      table:     '<%= table_name %>',
+      ran_on:    Time.now,
+      status:    'pending',
       direction: 'ActiveRecord to FileMaker'
     )
   end

data/lib/generators/harmonia/templates/add_server_id_to_harmonia_syncs.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class AddServerIdToHarmoniaSyncs < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
+  def change
+    unless column_exists?(:harmonia_syncs, :server_id)
+      add_column :harmonia_syncs, :server_id, :integer
+      add_index :harmonia_syncs, :server_id
+    end
+  end
+end

data/lib/generators/harmonia/templates/concerns/photo_syncable.rb

@@ -0,0 +1,28 @@
+require 'open-uri'
+
+module PhotoSyncable
+  def sync_photos(pg_records, fm_records, options: {})
+    attachment     = options[:attachment]      || 'photo'
+    container_field = options[:container_field] || 'foto'
+    filename_field  = options[:filename_field]  || 'foto_filename'
+    purge_existing  = options[:purge_existing]
+
+    pg_records.each do |record|
+      fm_record = fm_records.find { |r| r.id == record.filemaker_id }
+      record.send(attachment).purge if record.send(attachment).attached? && purge_existing
+      next unless fm_record.send(container_field).present?
+
+      downloaded_image = URI.parse(fm_record.send(container_field)).open
+      record.send(attachment).attach(io: downloaded_image, filename: fm_record.send(filename_field))
+    end
+  end
+
+  def sync_photo_to_filemaker(attachment, fm_record, options: {})
+    container_field = options[:container_field] || 'foto'
+    return unless attachment.blank?
+
+    attachment.open do |tempfile|
+      fm_record.upload(container_name: container_field, file: tempfile)
+    end
+  end
+end

data/lib/generators/harmonia/templates/concerns/related_model_resolver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RelatedModelResolver
+  # FM models extend this and define related_models to declare which FM fields
+  # must resolve to a local PG record. Returns a hash of resolved IDs, or nil
+  # if any required reference cannot be resolved.
+  #
+  # Example:
+  #   def self.related_models
+  #     [[:sales_region_id, ::SalesRegion], [:administration_id, ::Administration]]
+  #   end
+  def resolve_related_models(record)
+    related_models.each_with_object({}) do |(field, model), hash|
+      resolved = model.find_by(filemaker_id: record.send(field))&.id
+      return nil if resolved.nil?
+
+      hash[field] = resolved
+    end
+  end
+end

data/lib/generators/harmonia/templates/concerns/related_model_validation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RelatedModelValidation
+  def validate_related_models(record, fm_model_class)
+    references = fm_model_class.related_models.map { |field, model| [record.send(field), model] }
+    errors = references.filter_map do |fm_id, model|
+      label = model.name.demodulize.underscore
+      if fm_id.blank?
+        "#{label} is blank in FileMaker"
+      elsif model.find_by(filemaker_id: fm_id).nil?
+        "#{label} with FileMaker id '#{fm_id}' not found in PostgreSQL"
+      end
+    end
+    "Skipped: #{errors.join(', ')}" if errors.any?
+  end
+end

data/lib/generators/harmonia/templates/concerns/sync_loggable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SyncLoggable
+  def log_sync_start(table:, direction:, server_id: nil)
+    parts = ["[SYNC START] #{table} | #{direction}"]
+    parts << "server=#{server_id}" if server_id
+    Rails.logger.info(parts.join(' | '))
+  end
+
+  def log_sync_plan(table:, direction:, to_create:, to_update:, to_delete:)
+    Rails.logger.info(
+      "[SYNC PLAN ] #{table} | #{direction} | " \
+      "to_create=#{to_create} to_update=#{to_update} to_delete=#{to_delete}"
+    )
+  end
+
+  def log_sync_finish(table:, direction:, created:, updated:, deleted:, failed_fm:, failed_pg:, duration: nil)
+    parts = [
+      "[SYNC DONE ] #{table} | #{direction}",
+      "created=#{created} updated=#{updated} deleted=#{deleted}",
+      "failed_fm=#{failed_fm} failed_pg=#{failed_pg}"
+    ]
+    parts << "duration=#{duration.round(2)}s" if duration
+    Rails.logger.info(parts.join(' | '))
+  end
+
+  def log_sync_error(table:, direction:, error:)
+    Rails.logger.error("[SYNC ERROR] #{table} | #{direction} | #{error.class}: #{error.message}")
+  end
+
+  def log_create_error(id:, id_type: :fm, error:)
+    label = id_type == :fm ? "FileMaker ID" : "PostgreSQL ID"
+    Rails.logger.error("[SYNC] Failed to create record from #{label} #{id}: #{error.message}")
+  end
+
+  def log_update_error(id:, id_type: :fm, error:)
+    label = id_type == :fm ? "FileMaker ID" : "PostgreSQL ID"
+    Rails.logger.error("[SYNC] Failed to update record from #{label} #{id}: #{error.message}")
+  end
+
+  def log_delete_error(id:, id_type: :fm, error:)
+    label = id_type == :fm ? "FileMaker ID" : "PostgreSQL ID"
+    Rails.logger.error("[SYNC] Failed to delete record with #{label} #{id}: #{error.message}")
+  end
+
+  def log_needs_update_error(id:, id_type: :fm, error:)
+    label = id_type == :fm ? "FileMaker ID" : "PostgreSQL ID"
+    Rails.logger.error("[SYNC] Failed needs_update? check for #{label} #{id}: #{error.message}")
+  end
+end

data/lib/generators/harmonia/templates/concerns/sync_retryable.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Adds retry capability for FM IDs that failed in the previous sync run.
+#
+# Usage in a syncer:
+#   include SyncRetryable
+#
+#   def run
+#     ...
+#     @database_connector.open_database do
+#       sync_record.start!
+#       sync_records(sync_record)
+#       retry_failed_records(FileMaker::MyModel, table: 'my_models', direction: 'FileMaker to ActiveRecord')
+#     end
+#   end
+#
+# The concern reads failed_fm_ids from the previous completed/failed sync,
+# fetches those records from FileMaker, then calls retry_create / retry_update.
+# Syncers can override either hook for custom logic (e.g. photo handling).
+
+module SyncRetryable
+  def retry_failed_records(fm_model_class, table:, direction:)
+    previous_sync = Harmonia::Sync
+                    .where(table:, direction:, server_id: @server_id)
+                    .where(status: %w[completed failed])
+                    .order(ran_on: :desc)
+                    .offset(1) # skip the sync that just completed
+                    .first
+
+    return unless previous_sync
+
+    failed_fm_ids = previous_sync.failed_fm_ids.keys
+    return if failed_fm_ids.empty?
+
+    log_sync_retry_start(table:, direction:, count: failed_fm_ids.size, ids: failed_fm_ids)
+
+    fm_records = failed_fm_ids.filter_map do |fm_id|
+      fm_model_class.where(id: fm_id).first
+    rescue StandardError => e
+      Rails.logger.warn("[SYNC RETRY] Could not fetch FM record #{fm_id}: #{e.message}")
+      nil
+    end
+
+    pg_model = retryable_pg_model
+    to_create = fm_records.reject { |r| pg_model.exists?(filemaker_id: r.id) }
+    to_update = fm_records.select { |r| pg_model.exists?(filemaker_id: r.id) }
+
+    created = retry_create(to_create, fm_model_class)
+    updated = retry_update(to_update, fm_model_class)
+
+    log_sync_retry_finish(table:, direction:, created:, updated:)
+  end
+
+  private
+
+  # Override in the syncer for custom create logic (e.g. photo sync, insert_all).
+  def retry_create(fm_records, fm_model_class)
+    return 0 if fm_records.empty?
+
+    pg_model = retryable_pg_model
+    success = 0
+    fm_records.each do |trophonius_record|
+      attributes = fm_model_class.to_pg(trophonius_record).merge(
+        created_at: Time.current, updated_at: Time.current
+      )
+      pg_model.create!(attributes)
+      @failed_fm_ids.delete(trophonius_record.id.to_s)
+      success += 1
+    rescue StandardError => e
+      @failed_fm_ids[trophonius_record.id.to_s] = e.message
+      log_create_error(id: trophonius_record.id, error: e)
+    end
+    success
+  end
+
+  # Override in the syncer for custom update logic.
+  def retry_update(fm_records, fm_model_class)
+    return 0 if fm_records.empty?
+
+    pg_model = retryable_pg_model
+    success = 0
+    fm_records.each do |trophonius_record|
+      attributes = fm_model_class.to_pg(trophonius_record)
+      pg_model.where(filemaker_id: trophonius_record.id).update_all(
+        attributes.merge(updated_at: Time.current)
+      )
+      @failed_fm_ids.delete(trophonius_record.id.to_s)
+      success += 1
+    rescue StandardError => e
+      @failed_fm_ids[trophonius_record.id.to_s] = e.message
+      log_update_error(id: trophonius_record.id, error: e)
+    end
+    success
+  end
+
+  # Infers the PG model from the syncer class name. Override if naming diverges.
+  # AssetSyncer → Asset, AssetDefectSyncer → AssetDefect, etc.
+  def retryable_pg_model
+    self.class.name.delete_suffix('Syncer').constantize
+  end
+
+  def log_sync_retry_start(table:, direction:, count:, ids:)
+    Rails.logger.info(
+      "[SYNC RETRY] #{table} | #{direction} | retrying #{count} record(s) | ids=#{ids.join(',')}"
+    )
+  end
+
+  def log_sync_retry_finish(table:, direction:, created:, updated:)
+    Rails.logger.info(
+      "[SYNC RETRY] #{table} | #{direction} | created=#{created} updated=#{updated}"
+    )
+  end
+end

data/lib/generators/harmonia/templates/create_harmonia_syncs.rb

@@ -10,6 +10,7 @@ class CreateHarmoniaSyncs < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>
       t.string :status, default: 'pending'
       t.string :direction
       t.text :error_message
+      t.integer :server_id
       t.jsonb :failed_fm_ids, default: {}
       t.jsonb :failed_pg_ids, default: {}
 
@@ -18,5 +19,6 @@ class CreateHarmoniaSyncs < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>
 
     add_index :harmonia_syncs, [:table, :ran_on]
     add_index :harmonia_syncs, :status
+    add_index :harmonia_syncs, :server_id
   end
 end

data/lib/generators/harmonia/templates/filemaker_to_activerecord_syncer_template.rb

@@ -1,27 +1,38 @@
 # frozen_string_literal: true
 
 class <%= class_name %>Syncer
+  include SyncLoggable
+  include SyncRetryable
+
   attr_accessor :database_connector
 
-  def initialize(database_connector)
+  def initialize(database_connector, server_id, update_only: false)
     @database_connector = database_connector
-    @last_synced_on = Harmonia::Sync.last_sync_for('<%= table_name %>', 'FileMaker to ActiveRecord')&.ran_on || (Time.now - 15.year)
+    @server_id = server_id
+    @last_synced_on = if update_only
+                        Time.now - 100.years
+                      else
+                        Harmonia::Sync.last_sync_for('<%= table_name %>', 'FileMaker to ActiveRecord', server_id)&.ran_on || (Time.now - 15.years)
+                      end
+    @update_only = update_only
     @failed_fm_ids = {}
     @failed_pg_ids = {}
   end
 
-  # Main sync method
-  # Executes the sync process for <%= class_name %> records
   def run
     raise StandardError, 'No database connector set' if @database_connector.blank?
 
     sync_record = create_sync_record
+    @sync_started_at = Time.now
+    log_sync_start(table: '<%= table_name %>', direction: 'FileMaker to ActiveRecord', server_id: @server_id)
 
     @database_connector.open_database do
       sync_record.start!
       sync_records(sync_record)
+      retry_failed_records(FileMaker::<%= class_name %>, table: '<%= table_name %>', direction: 'FileMaker to ActiveRecord')
     end
   rescue StandardError => e
+    log_sync_error(table: '<%= table_name %>', direction: 'FileMaker to ActiveRecord', error: e)
     sync_record&.fail!(e.message, failed_fm_ids: @failed_fm_ids, failed_pg_ids: @failed_pg_ids)
     raise
   end
@@ -30,78 +41,77 @@ class <%= class_name %>Syncer
 
   def sync_records(sync_record)
     updated_count = update_records
-    created_count = create_records
-    delete_records
+    created_count = @update_only ? 0 : create_records
+    deleted_count = @update_only ? 0 : delete_records.to_i
 
-    total_synced = created_count + updated_count
+    total_synced   = created_count + updated_count
     total_required = (@total_create_required || 0) + (@total_update_required || 0)
 
+    log_sync_plan(
+      table: '<%= table_name %>', direction: 'FileMaker to ActiveRecord',
+      to_create: @total_create_required || 0,
+      to_update: @total_update_required || 0,
+      to_delete: deleted_count
+    )
+
     sync_record.finish!(
-      records_synced: total_synced,
+      records_synced:   total_synced,
       records_required: total_required,
-      failed_fm_ids: @failed_fm_ids,
-      failed_pg_ids: @failed_pg_ids
+      failed_fm_ids:    @failed_fm_ids,
+      failed_pg_ids:    @failed_pg_ids
+    )
+
+    log_sync_finish(
+      table: '<%= table_name %>', direction: 'FileMaker to ActiveRecord',
+      created: created_count, updated: updated_count, deleted: deleted_count,
+      failed_fm: @failed_fm_ids.size, failed_pg: @failed_pg_ids.size,
+      duration: Time.now - @sync_started_at
     )
   end
 
-  # Returns an array of Trophonius records that need to be created
-  # Use FileMaker::<%= class_name %>.to_pg(record) to convert to PostgreSQL attributes
-  # Set @total_create_required to the total number of records that should exist after creation
-  # @return [Array<Trophonius::Record>] Array of Trophonius records
+  # Returns FileMaker records that need to be created in PostgreSQL.
+  # Set @total_create_required to the count of records that should be created.
   def records_to_create
-    # TODO: Implement logic to fetch records from FileMaker that need to be created in PostgreSQL
-    # Example:
-    filemaker_records = FileMaker::<%= class_name %>.where(creation_timestamp: ">= #{@last_synced_on.to_fm}").not
-    @total_create_required = filemaker_records.length
+    # TODO: implement
     existing_ids = <%= class_name %>.pluck(:filemaker_id)
-    filemaker_records.reject { |record| existing_ids.include?(record.id) }
+    filemaker_records = FileMaker::<%= class_name %>.where(creation_timestamp: ">= #{@last_synced_on.to_fm}")
+    filemaker_records.reject! { |record| existing_ids.include?(record.id) }
+    @total_create_required = filemaker_records.length
+    filemaker_records
   end
 
-  # Returns an array of Trophonius records that need to be updated
-  # Use FileMaker::<%= class_name %>.to_pg(record) to convert to PostgreSQL attributes
-  # Set @total_update_required to the total number of records that should be updated
-  # @return [Array<Trophonius::Record>] Array of Trophonius records
+  # Returns FileMaker records that need to be updated in PostgreSQL.
+  # Set @total_update_required to the count of records that should be updated.
   def records_to_update
-    # TODO: Implement logic to fetch records from FileMaker that need to be updated in PostgreSQL
-    # Example:
+    # TODO: implement
     filemaker_records = FileMaker::<%= class_name %>.where(modification_timestamp: ">= #{@last_synced_on.to_fm}")
-    records_needing_update = filemaker_records.select { |fm_record|
-      pg_record = <%= class_name %>.find_by(filemaker_id: fm_record.record_id)
+    records_needing_update = filemaker_records.select do |fm_record|
+      pg_record = <%= class_name %>.find_by(filemaker_id: fm_record.id)
       pg_record && needs_update?(fm_record, pg_record)
-    }
+    end
     @total_update_required = records_needing_update.length
     records_needing_update
   end
 
-  # Returns an array of record identifiers that need to be deleted
-  # @return [Array] Array of record identifiers
+  # Returns PostgreSQL IDs of records that have been deleted in FileMaker.
   def records_to_delete
-    # Get all modified FileMaker record IDs
     filemaker_records = FileMaker::<%= class_name %>.where(modification_timestamp: ">= #{@last_synced_on.to_fm}")
-    fm_ids = filemaker_records.map(&:record_id)
+    fm_ids = filemaker_records.map(&:id)
 
-    # Find PostgreSQL records whose FileMaker IDs aren't in the modified set
-    # These might have been deleted in FileMaker
     fm_ids_no_update_needed = <%= class_name %>.where.not(filemaker_id: fm_ids).pluck(:filemaker_id)
     return [] if fm_ids_no_update_needed.empty?
 
-    # Query FileMaker to check if these records still exist
-    possibly_deleted_query = FileMaker::<%= class_name %>.where(record_id: fm_ids_no_update_needed.first)
+    possibly_deleted_query = FileMaker::<%= class_name %>.where(id: fm_ids_no_update_needed.first)
     fm_ids_no_update_needed.count > 1 && fm_ids_no_update_needed[1..].each do |fm_id|
-      possibly_deleted_query.or(record_id: fm_id)
+      possibly_deleted_query.or(id: fm_id)
     end
 
-    # Find IDs that exist in PostgreSQL but not in FileMaker (truly deleted)
-    deleted_fm_ids = fm_ids_no_update_needed - possibly_deleted_query.map(&:record_id)
-
-    # Return PostgreSQL IDs for records with these FileMaker IDs
+    deleted_fm_ids = fm_ids_no_update_needed - possibly_deleted_query.map(&:id)
     <%= class_name %>.where(filemaker_id: deleted_fm_ids).pluck(:id)
   end
 
   def needs_update?(fm_record, pg_record)
-    pg_attributes = FileMaker::<%= class_name %>.to_pg(fm_record)
-
-    pg_attributes.any? { |key, value| pg_record.send(key) != value }
+    FileMaker::<%= class_name %>.to_pg(fm_record).any? { |key, value| pg_record.send(key) != value }
   end
 
   def create_records
@@ -109,21 +119,17 @@ class <%= class_name %>Syncer
     return 0 if records.empty?
 
     success_count = 0
-
     records.each do |trophonius_record|
-      begin
-        attributes = FileMaker::<%= class_name %>.to_pg(trophonius_record).merge(
-          created_at: Time.current,
-          updated_at: Time.current
-        )
-        <%= class_name %>.create!(attributes)
-        success_count += 1
-      rescue StandardError => e
-        @failed_fm_ids[trophonius_record.record_id.to_s] = e.message
-        Rails.logger.error("Failed to create record from FileMaker ID #{trophonius_record.record_id}: #{e.message}")
-      end
+      attributes = FileMaker::<%= class_name %>.to_pg(trophonius_record).merge(
+        created_at: Time.current,
+        updated_at: Time.current
+      )
+      <%= class_name %>.create!(attributes)
+      success_count += 1
+    rescue StandardError => e
+      @failed_fm_ids[trophonius_record.id.to_s] = e.message
+      log_create_error(id: trophonius_record.id, error: e)
     end
-
     success_count
   end
 
@@ -132,21 +138,16 @@ class <%= class_name %>Syncer
     return 0 if records.empty?
 
     success_count = 0
-
     records.each do |trophonius_record|
-      begin
-        pg_attributes = FileMaker::<%= class_name %>.to_pg(trophonius_record)
-
-        <%= class_name %>.where(filemaker_id: trophonius_record.record_id).update_all(
-          pg_attributes.merge(updated_at: Time.current)
-        )
-        success_count += 1
-      rescue StandardError => e
-        @failed_fm_ids[trophonius_record.record_id.to_s] = e.message
-        Rails.logger.error("Failed to update record from FileMaker ID #{trophonius_record.record_id}: #{e.message}")
-      end
+      pg_attributes = FileMaker::<%= class_name %>.to_pg(trophonius_record)
+      <%= class_name %>.where(filemaker_id: trophonius_record.id).update_all(
+        pg_attributes.merge(updated_at: Time.current)
+      )
+      success_count += 1
+    rescue StandardError => e
+      @failed_fm_ids[trophonius_record.id.to_s] = e.message
+      log_update_error(id: trophonius_record.id, error: e)
     end
-
     success_count
   end
 
@@ -155,20 +156,19 @@ class <%= class_name %>Syncer
     return if ids.empty?
 
     ids.each do |pg_id|
-      begin
-        <%= class_name %>.where(id: pg_id).destroy_all
-      rescue StandardError => e
-        @failed_pg_ids[pg_id.to_s] = e.message
-        Rails.logger.error("Failed to delete record with PostgreSQL ID #{pg_id}: #{e.message}")
-      end
+      <%= class_name %>.where(id: pg_id).destroy_all
+    rescue StandardError => e
+      @failed_pg_ids[pg_id.to_s] = e.message
+      log_delete_error(id: pg_id, id_type: :pg, error: e)
     end
   end
 
   def create_sync_record
     Harmonia::Sync.create!(
-      table: '<%= table_name %>',
-      ran_on: Time.now,
-      status: 'pending',
+      table:     '<%= table_name %>',
+      ran_on:    Time.now,
+      status:    'pending',
+      server_id: @server_id,
       direction: 'FileMaker to ActiveRecord'
     )
   end

data/lib/generators/harmonia/templates/harmonia_sync.rb

@@ -8,44 +8,36 @@ module Harmonia
     validates :ran_on, presence: true
     validates :status, presence: true, inclusion: { in: %w[pending in_progress completed failed] }
 
-    # Scope to get syncs for a specific table
     scope :for_table, ->(table_name) { where(table: table_name) }
-    scope :for_direction, ->(direction) {where(direction:)}
-
-    # Scope to get recent syncs
+    scope :for_direction, ->(direction) { where(direction:) }
+    scope :for_server, ->(server_id) { where(server_id:) }
     scope :recent, -> { order(ran_on: :desc) }
-
-    # Scope to get syncs by date
     scope :on_date, ->(date) { where(ran_on: date) }
-
-    # Scope by status
     scope :pending, -> { where(status: 'pending') }
     scope :in_progress, -> { where(status: 'in_progress') }
     scope :completed, -> { where(status: 'completed') }
     scope :failed, -> { where(status: 'failed') }
 
-    # Get the most recent successful sync for a table in a given direction
-    def self.last_sync_for(table_name, direction)
-      completed.for_direction(direction).for_table(table_name).recent.first
+    def self.last_sync_for(table_name, direction, server_id = nil)
+      scope = completed.for_direction(direction).for_table(table_name)
+      scope = server_id ? scope.for_server(server_id) : scope.where(server_id: nil)
+      scope.recent.first
     end
 
-    # Calculate sync completion percentage
     def completion_percentage
       return 0 if records_required.to_i.zero?
+
       ((records_synced.to_f / records_required.to_f) * 100).round(2)
     end
 
-    # Check if sync was complete
     def complete?
       status == 'completed' && records_synced == records_required
     end
 
-    # Mark sync as started
     def start!
       update!(status: 'in_progress')
     end
 
-    # Mark sync as completed
     def finish!(records_synced:, records_required:, failed_fm_ids: {}, failed_pg_ids: {})
       status = records_synced == records_required ? 'completed' : 'failed'
       update!(
@@ -57,7 +49,6 @@ module Harmonia
       )
     end
 
-    # Mark sync as failed
     def fail!(error_message, failed_fm_ids: {}, failed_pg_ids: {})
       update!(
         status: 'failed',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harmonia
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Kempen Automatisering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-17 00:00:00.000000000 Z
+date: 2026-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trophonius
@@ -39,7 +39,13 @@ files:
 - lib/generators/harmonia/templates/activerecord_to_filemaker_syncer_template.rb
 - lib/generators/harmonia/templates/add_failed_ids_to_harmonia_syncs.rb
 - lib/generators/harmonia/templates/add_filemaker_id_to_table.rb
+- lib/generators/harmonia/templates/add_server_id_to_harmonia_syncs.rb
 - lib/generators/harmonia/templates/application_record_extension.rb
+- lib/generators/harmonia/templates/concerns/photo_syncable.rb
+- lib/generators/harmonia/templates/concerns/related_model_resolver.rb
+- lib/generators/harmonia/templates/concerns/related_model_validation.rb
+- lib/generators/harmonia/templates/concerns/sync_loggable.rb
+- lib/generators/harmonia/templates/concerns/sync_retryable.rb
 - lib/generators/harmonia/templates/create_harmonia_syncs.rb
 - lib/generators/harmonia/templates/database_connector.rb
 - lib/generators/harmonia/templates/filemaker_to_activerecord_syncer_template.rb