v3.0.3: keep Harvest import names distinct (#2432)

* fix: keep Harvest import names distinct

* chore: release v3.0.3

* fix: stabilize Harvest names across imports

* fix: normalize Harvest import identities

* fix: preserve legacy Harvest import identities

Author: vipulnsward

CHANGELOG.md

@@ -26,6 +26,12 @@
 - Mailer layout branding now uses asset helper URLs with production `action_mailer.asset_host` to keep email logo assets resolvable in production mail clients
 - Razorpay Payment Settings now copies the production webhook URLs with the required event names for faster dashboard setup
 
+## 3.0.3 - 2026-09-07
+
+### Fixed
+
+- Harvest imports now keep long client and project names distinct when their 30-character prefixes collide
+
 ## 3.0.2 - 2026-09-07
 
 ### Fixed

VERSION

@@ -1 +1 @@
-3.0.2
+3.0.3

app/services/imports/harvest_time_entries_importer.rb

@@ -118,6 +118,7 @@ def load_workspace_records
           .includes(:client)
           .to_a
           .index_by { |project| [project.client_id, key(project.name)] }
+        load_legacy_names
       end
 
       def build_plan
@@ -169,12 +170,17 @@ def build_entity_plans
           client_key, client_plan = build_client_plan(row)
 
           original_project_name = row[:project_name]
-          project_name = original_project_name[0, 30]
+          project_name = import_name(original_project_name)
+          existing_project = client_plan[:existing] && @existing_projects[[client_plan[:existing].id, key(project_name)]]
+          if existing_project.nil? && (legacy_name = legacy_import_name(original_project_name, @legacy_project_names))
+            existing_project = client_plan[:existing] && @existing_projects[[client_plan[:existing].id, key(legacy_name)]]
+            project_name = legacy_name if existing_project
+          end
           @warnings << "Project name truncated: #{original_project_name.truncate(80)}" if original_project_name.length > 30
           project_key = [client_key, key(project_name)]
-          existing_project = client_plan[:existing] && @existing_projects[[client_plan[:existing].id, key(project_name)]]
           row[:project_plan] = @project_plans[project_key] ||= {
             name: project_name,
+            source_name: original_project_name,
             client: client_plan,
             existing: existing_project,
             billable: false,
@@ -189,7 +195,10 @@ def build_entity_plans
 
       def build_client_plan(row)
         original_name = row[:client_name]
-        client_name = original_name[0, 30]
+        client_name = import_name(original_name)
+        if !@existing_clients.key?(key(client_name)) && (legacy_name = legacy_import_name(original_name, @legacy_client_names))
+          client_name = legacy_name if @existing_clients.key?(key(legacy_name))
+        end
         @warnings << "Client name truncated: #{original_name.truncate(80)}" if original_name.length > 30
         client_key = key(client_name)
         client_plan = @client_plans[client_key] ||= {
@@ -201,6 +210,36 @@ def build_client_plan(row)
         [client_key, client_plan]
       end
 
+      def import_name(name)
+        return name if name.length <= 30
+
+        suffix = "-#{Digest::SHA256.hexdigest(key(name)).first(6)}"
+        "#{name.first(30 - suffix.length)}#{suffix}"
+      end
+
+      def load_legacy_names
+        warnings = company.data_imports.where(source: "harvest", kind: "time_entries", status: "completed", dry_run: false)
+          .pluck(:summary)
+          .flat_map { |summary| Array(summary["warnings"]) }
+        @legacy_client_names = legacy_names(warnings, "Client")
+        @legacy_project_names = legacy_names(warnings, "Project")
+      end
+
+      def legacy_names(warnings, entity)
+        prefix = "#{entity} name truncated: "
+        names = warnings.filter_map do |warning|
+          warning.delete_prefix(prefix) if warning.start_with?(prefix) && !warning.end_with?("...")
+        end
+        names.group_by { |name| key(name.first(30)) }.transform_values do |matches|
+          matches.first if matches.map { |name| key(name) }.uniq.one?
+        end.compact
+      end
+
+      def legacy_import_name(name, legacy_names)
+        legacy_name = legacy_names[key(name.first(30))]
+        name.first(30) if legacy_name && key(legacy_name) == key(name)
+      end
+
       def plan_row(row)
         error = row_error(row)
         return add_row_error(row, error) if error
@@ -381,13 +420,20 @@ def create_clients_and_projects
             plan[:record] = plan[:existing] || plan[:client][:record].projects.create!(
               name: plan[:name],
               billable: plan[:billable],
-              description: plan[:code] && "Harvest project code: #{plan[:code]}"
+              description: project_description(plan)
             )
             plan[:record].undiscard! if plan[:record].discarded?
           end
         end
       end
 
+      def project_description(plan)
+        [
+          ("Harvest project: #{plan[:source_name]}" if plan[:source_name] != plan[:name]),
+          ("Harvest project code: #{plan[:code]}" if plan[:code])
+        ].compact.join("\n").presence
+      end
+
       def create_project_members
         pairs = @planned_rows.each_with_object({}) do |row, result|
           result[[row[:project_plan][:record].id, row[:user].id]] ||= row

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saeloun/miru-web",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "dependencies": {
     "@fontsource-variable/inter": "^5.2.6",
     "@fontsource/plus-jakarta-sans": "^4.5.0",

spec/services/imports/harvest_time_entries_importer_spec.rb

@@ -28,7 +28,7 @@
       failed_rows: 0,
       skipped_rows: 1
     )
-    expect(company.clients.kept.pluck(:name)).to contain_exactly("Acme LLC", "Very Long Client Name That Exc")
+    expect(company.clients.kept.pluck(:name)).to contain_exactly("Acme LLC", "Very Long Client Name T-715152")
     expect(company.projects.kept.count).to eq(3)
     expect(ProjectMember.kept.joins(project: :client).where(clients: { company_id: company.id }).count).to eq(3)
 
@@ -43,7 +43,7 @@
     internal = company.projects.kept.find_by!(name: "Internal")
     expect(internal).not_to be_billable
     expect(internal.timesheet_entries.kept).to all(be_non_billable)
-    expect(company.clients.kept.find_by!(name: "Very Long Client Name That Exc").currency).to eq("USD")
+    expect(company.clients.kept.find_by!(name: "Very Long Client Name T-715152").currency).to eq("USD")
     expect(website.project_members.kept.find_by!(user: paul).hourly_rate).to eq(150)
   end
 
@@ -153,11 +153,11 @@
         "zero_hour_skipped" => 1,
         "duplicates_skipped" => 0
       )
-      expect(data_import.summary.dig("clients", "to_create")).to contain_exactly("Acme LLC", "Very Long Client Name That Exc")
+      expect(data_import.summary.dig("clients", "to_create")).to contain_exactly("Acme LLC", "Very Long Client Name T-715152")
       expect(data_import.summary.dig("projects", "to_create")).to contain_exactly(
         "Acme LLC / Internal",
         "Acme LLC / Website",
-        "Very Long Client Name That Exc / Advisory"
+        "Very Long Client Name T-715152 / Advisory"
       )
       expect(data_import.summary.dig("date_range")).to eq("from" => "2026-01-02", "to" => "2026-01-11")
       expect(data_import.summary).not_to have_key("row_errors")
@@ -188,6 +188,88 @@
     expect(TimesheetEntry.kept.last.work_date).to eq(Date.new(2026, 1, 7))
   end
 
+  it "keeps project names distinct when their 30-character prefixes collide" do
+    attach_csv_contents(data_import, <<~CSV)
+      Date,Client,Project,Project Code,Hours,First Name,Last Name
+      2026-01-01,Acme LLC,Acme 1H 2025 Committed Hours (PC),PC,1,Paul,Connors
+    CSV
+
+    described_class.new(data_import).process
+
+    second_import = create(:data_import, company:, user: actor)
+    attach_csv_contents(second_import, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name
+      2026-01-02,Acme LLC,Acme 1H 2025 Committed Hours (LW),1,Paul,Connors
+    CSV
+    described_class.new(second_import).process
+
+    projects = company.projects.kept.order(:name)
+    expect(projects.pluck(:name).uniq.size).to eq(2)
+    expect(projects.pluck(:name).map(&:length)).to all(be <= 30)
+    expect(projects.pluck(:description)).to contain_exactly(
+      "Harvest project: Acme 1H 2025 Committed Hours (LW)",
+      "Harvest project: Acme 1H 2025 Committed Hours (PC)\nHarvest project code: PC"
+    )
+    expect(projects.flat_map { |project| project.timesheet_entries.kept.pluck(:work_date) }).to contain_exactly(
+      Date.new(2026, 1, 1),
+      Date.new(2026, 1, 2)
+    )
+    expect(data_import.reload.summary["warnings"]).to include(match(/Project name truncated:/))
+
+    reimport = create(:data_import, company:, user: actor)
+    attach_csv_contents(reimport, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name
+      2026-01-02,Acme LLC,Acme 1H 2025 Committed Hours (LW),1,Paul,Connors
+      2026-01-01,Acme LLC,Acme 1H 2025 Committed Hours (PC),1,Paul,Connors
+    CSV
+
+    expect do
+      described_class.new(reimport).process
+    end.not_to change { [company.projects.kept.count, TimesheetEntry.kept.count] }
+    expect(reimport.reload).to have_attributes(imported_rows: 0, skipped_rows: 2)
+  end
+
+  it "keeps client names distinct when their 30-character prefixes collide" do
+    attach_csv_contents(data_import, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name
+      2026-01-01,Acme Corporate Legal Services Alpha,Website,1,Paul,Connors
+    CSV
+
+    described_class.new(data_import).process
+
+    second_import = create(:data_import, company:, user: actor)
+    attach_csv_contents(second_import, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name
+      2026-01-02,Acme Corporate Legal Services Bravo,Website,1,Paul,Connors
+    CSV
+    described_class.new(second_import).process
+
+    expect(company.clients.kept.pluck(:name).uniq.size).to eq(2)
+    expect(company.projects.kept.count).to eq(2)
+    expect(data_import.reload.summary["warnings"]).to include(match(/Client name truncated:/))
+  end
+
+  it "reuses unambiguous client and project names created by the legacy importer" do
+    client_name = "Acme Corporate Legal Services Alpha"
+    project_name = "Acme 1H 2025 Committed Hours (PC)"
+    create(:data_import, company:, user: actor, status: "completed", summary: {
+      "warnings" => ["Client name truncated: #{client_name}", "Project name truncated: #{project_name}"]
+    })
+    legacy_client = create(:client, company:, name: client_name.first(30))
+    legacy_project = create(:project, client: legacy_client, name: project_name.first(30))
+    create(:timesheet_entry, project: legacy_project, user: paul, work_date: Date.new(2026, 1, 1), duration: 60, note: "", source: "import")
+    attach_csv_contents(data_import, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name
+      2026-01-01,#{client_name},#{project_name},1,Paul,Connors
+    CSV
+
+    expect do
+      described_class.new(data_import).process
+    end.not_to change { [company.clients.count, company.projects.count, TimesheetEntry.count] }
+
+    expect(data_import.reload).to have_attributes(imported_rows: 0, skipped_rows: 1)
+  end
+
   it "records invalid hours, date, and blank client rows without creating entries" do
     attach_csv_contents(data_import, <<~CSV)
       Date,Client,Project,Hours,First Name,Last Name
@@ -238,21 +320,30 @@
     )
   end
 
-  it "truncates project names and reuses a matching project" do
+  it "shortens long project names deterministically" do
     client = create(:client, company:, name: "Acme LLC")
-    project = create(:project, client:, name: "A Project Name Longer Than Thi", billable: true)
     attach_csv_contents(data_import, <<~CSV)
       Date,Client,Project,Hours,First Name,Last Name,Billable?
       2026-01-01,Acme LLC,A Project Name Longer Than Thirty Characters,1,Paul,Connors,Yes
     CSV
 
     described_class.new(data_import).process
 
-    expect(client.projects.count).to eq(1)
+    project = client.projects.find_by!(name: "A Project Name Longer T-ae2f52")
     expect(project.timesheet_entries.kept).to exist
     expect(data_import.reload.summary["warnings"]).to include(
       "Project name truncated: A Project Name Longer Than Thirty Characters"
     )
+
+    reimport = create(:data_import, company:, user: actor)
+    attach_csv_contents(reimport, <<~CSV)
+      Date,Client,Project,Hours,First Name,Last Name,Billable?
+      2026-01-01,Acme LLC,A PROJECT NAME LONGER THAN THIRTY CHARACTERS,1,Paul,Connors,Yes
+    CSV
+
+    expect do
+      described_class.new(reimport).process
+    end.not_to change { [client.projects.count, TimesheetEntry.kept.count] }
   end
 
   it "restores an archived client before importing entries" do