Reduce reliance on Timex and use native time API where feasible

lib/plausible/auth/totp.ex

@@ -336,7 +336,9 @@ defmodule Plausible.Auth.TOTP do
       |> Repo.one()
 
     if datetime do
-      Timex.to_unix(datetime)
+      datetime
+      |> DateTime.from_naive!("Etc/UTC")
+      |> DateTime.to_unix()
     end
   end
 

lib/plausible/billing/subscriptions.ex

@@ -27,7 +27,7 @@ defmodule Plausible.Billing.Subscriptions do
 
   def expired?(%Subscription{next_bill_date: next_bill_date} = subscription) do
     deleted? = Subscription.Status.deleted?(subscription)
-    expired? = Timex.compare(next_bill_date, Date.utc_today()) < 0
+    expired? = Date.before?(next_bill_date, Date.utc_today())
 
     deleted? && expired?
   end

lib/plausible/data_migration/populate_event_session_columns.ex

@@ -150,8 +150,6 @@ defmodule Plausible.DataMigration.PopulateEventSessionColumns do
   end
 
   defp format_duration(seconds) do
-    seconds
-    |> Timex.Duration.from_seconds()
-    |> Timex.format_duration(Timex.Format.Duration.Formatters.Humanized)
+    Plausible.Times.humanize_seconds(seconds)
   end
 end

lib/plausible/exports.ex

@@ -154,7 +154,7 @@ defmodule Plausible.Exports do
             ["expiry-date=", expiry_date, ", rule-id=", _rule_id] =
               String.split(x_amz_expiration, "\"", trim: true)
 
-            Timex.parse!(expiry_date, "{RFC1123}")
+            Plausible.Times.parse!(expiry_date, "{RFC1123}")
           end
 
         %{

lib/plausible/google/api.ex

@@ -3,8 +3,6 @@ defmodule Plausible.Google.API do
   API to Google services.
   """
 
-  use Timex
-
   alias Plausible.Google.HTTP
   alias Plausible.Google.SearchConsole
   alias Plausible.Stats.Query

lib/plausible/google/ga4/http.ex

@@ -269,7 +269,7 @@ defmodule Plausible.Google.GA4.HTTP do
         date =
           case report["rows"] do
             [%{"dimensionValues" => [%{"value" => date_str}]}] ->
-              Timex.parse!(date_str, "%Y%m%d", :strftime) |> NaiveDateTime.to_date()
+              Plausible.Times.parse!(date_str, "%Y%m%d", :strftime) |> NaiveDateTime.to_date()
 
             _ ->
               nil

lib/plausible/imported/google_analytics4.ex

@@ -337,7 +337,7 @@ defmodule Plausible.Imported.GoogleAnalytics4 do
 
   defp get_date(%{dimensions: %{"date" => date}}) do
     date
-    |> Timex.parse!("%Y%m%d", :strftime)
+    |> Plausible.Times.parse!("%Y%m%d", :strftime)
     |> NaiveDateTime.to_date()
   end
 

lib/plausible/site.ex

@@ -222,7 +222,7 @@ defmodule Plausible.Site do
   defp validate_timezone(changeset) do
     tz = get_field(changeset, :timezone)
 
-    if Timex.is_valid_timezone?(tz) do
+    if Plausible.Timezones.valid?(tz) do
       changeset
     else
       add_error(changeset, :timezone, "is invalid")

lib/plausible/stats/filters/query_parser.ex

@@ -197,8 +197,12 @@ defmodule Plausible.Stats.Filters.QueryParser do
   end
 
   defp parse_date(site, date_string, _date, _now) when is_binary(date_string) do
-    case Date.from_iso8601(date_string) do
-      {:ok, date} -> {:ok, date, DateTime.new!(date, ~T[00:00:00], site.timezone)}
+    with {:ok, date} <- Date.from_iso8601(date_string),
+         {:ok, datetime} <- DateTime.new(date, ~T[00:00:00], site.timezone) do
+      {:ok, date, datetime}
+    else
+      {:gap, just_before, _just_after} -> just_before
+      {:ambiguous, first_datetime, _second_datetime} -> first_datetime
       _ -> {:error, "Invalid date '#{date_string}'."}
     end
   end
@@ -231,8 +235,8 @@ defmodule Plausible.Stats.Filters.QueryParser do
   end
 
   defp parse_time_range(site, "year", date, _now) do
-    last = date |> Timex.end_of_year()
-    first = last |> Timex.beginning_of_year()
+    last = date |> Plausible.Times.end_of_year()
+    first = last |> Plausible.Times.beginning_of_year()
     {:ok, DateTimeRange.new!(first, last, site.timezone)}
   end
 

lib/plausible/stats/interval.ex

@@ -42,7 +42,7 @@ defmodule Plausible.Stats.Interval do
   """
   def default_for_date_range(%DateTimeRange{first: first, last: last}) do
     cond do
-      Timex.diff(last, first, :months) > 0 ->
+      Plausible.Times.diff(last, first, :month) > 0 ->
         "month"
 
       DateTime.diff(last, first, :day) > 0 ->
@@ -75,15 +75,15 @@ defmodule Plausible.Stats.Interval do
     table =
       with %Date{} = from <- Keyword.get(opts, :from),
            %Date{} = to <- Keyword.get(opts, :to),
-           true <- abs(Timex.diff(from, to, :months)) > 12 do
+           true <- abs(Plausible.Times.diff(from, to, :month)) > 12 do
         Map.replace(@valid_by_period, "custom", ["week", "month"])
       else
         _ ->
           @valid_by_period
       end
 
     with %Date{} = stats_start <- Plausible.Sites.stats_start_date(site),
-         true <- abs(Timex.diff(Date.utc_today(), stats_start, :months)) > 12 do
+         true <- abs(Plausible.Times.diff(Date.utc_today(), stats_start, :month)) > 12 do
       Map.replace(table, "all", ["week", "month"])
     else
       _ ->

lib/plausible/stats/legacy/legacy_query_builder.ex

@@ -157,9 +157,9 @@ defmodule Plausible.Stats.Legacy.QueryBuilder do
   defp put_input_date_range(query, site, %{"period" => "year"} = params) do
     end_date =
       parse_single_date(query, params)
-      |> Timex.end_of_year()
+      |> Plausible.Times.end_of_year()
 
-    start_date = Timex.beginning_of_year(end_date)
+    start_date = Plausible.Times.beginning_of_year(end_date)
 
     datetime_range =
       DateTimeRange.new!(start_date, end_date, site.timezone)
@@ -304,12 +304,12 @@ defmodule Plausible.Stats.Legacy.QueryBuilder do
   end
 
   defp today(query) do
-    query.now |> Timex.to_date()
+    query.now |> DateTime.to_date()
   end
 
   defp parse_single_date(query, params) do
     case params["date"] do
-      "today" -> query.now |> Timex.to_date()
+      "today" -> query.now |> DateTime.to_date()
       date when is_binary(date) -> Date.from_iso8601!(date)
       _ -> today(query)
     end

lib/plausible/stats/query_optimizer.ex

@@ -95,7 +95,7 @@ defmodule Plausible.Stats.QueryOptimizer do
     cond do
       DateTime.diff(last, first, :hour) <= 48 -> "time:hour"
       DateTime.diff(last, first, :day) <= 40 -> "time:day"
-      Timex.diff(last, first, :weeks) <= 52 -> "time:week"
+      Plausible.Times.diff(last, first, :week) <= 52 -> "time:week"
       true -> "time:month"
     end
   end

lib/plausible/stats/time.ex

@@ -53,10 +53,10 @@ defmodule Plausible.Stats.Time do
     date_range = Query.date_range(query)
 
     n_buckets =
-      Timex.diff(
+      Plausible.Times.diff(
         date_range.last,
         Date.beginning_of_month(date_range.first),
-        :months
+        :month
       )
 
     Enum.map(n_buckets..0//-1, fn shift ->
@@ -71,10 +71,10 @@ defmodule Plausible.Stats.Time do
     date_range = Query.date_range(query)
 
     n_buckets =
-      Timex.diff(
+      Plausible.Times.diff(
         date_range.last,
         Date.beginning_of_week(date_range.first),
-        :weeks
+        :week
       )
 
     Enum.map(0..n_buckets, fn shift ->

lib/plausible/teams/billing.ex

@@ -435,7 +435,7 @@ defmodule Plausible.Teams.Billing do
     last_bill_date = team.subscription.last_bill_date
 
     normalized_last_bill_date =
-      Date.shift(last_bill_date, month: Timex.diff(today, last_bill_date, :months))
+      Date.shift(last_bill_date, month: Plausible.Times.diff(today, last_bill_date, :month))
 
     date_range =
       case cycle do

lib/plausible/times.ex

@@ -0,0 +1,76 @@
+defmodule Plausible.Times do
+  @moduledoc """
+  API for working with time wrapping around external libraries where necessary.
+  """
+
+  @spec today(String.t()) :: Date.t()
+  def today(tz) do
+    tz
+    |> DateTime.now!()
+    |> DateTime.to_date()
+  end
+
+  @spec diff(Date.t() | DateTime.t(), Date.t() | DateTime.t(), :month | :week) :: integer()
+  def diff(a, b, unit) do
+    unit =
+      case unit do
+        :week -> :weeks
+        :month -> :months
+      end
+
+    Timex.diff(a, b, unit)
+  end
+
+  @spec parse!(String.t(), String.t(), :default | :strftime) :: DateTime.t() | NaiveDateTime.t()
+  def parse!(str, format, tokenizer \\ :default)
+
+  def parse!(str, "{RFC1123}" = format, :default) do
+    Timex.parse!(str, format)
+  end
+
+  def parse!(str, format, :strftime) do
+    Timex.parse!(str, format, :strftime)
+  end
+
+  @spec beginning_of_week(DateTime.t()) :: DateTime.t()
+  def beginning_of_week(dt) do
+    Timex.beginning_of_week(dt)
+  end
+
+  @spec beginning_of_month(DateTime.t()) :: DateTime.t()
+  def beginning_of_month(dt) do
+    Timex.beginning_of_month(dt)
+  end
+
+  @spec beginning_of_year(Date.t()) :: Date.t()
+  def beginning_of_year(d) do
+    Timex.beginning_of_year(d)
+  end
+
+  @spec end_of_week(DateTime.t()) :: DateTime.t()
+  def end_of_week(dt) do
+    Timex.end_of_week(dt)
+  end
+
+  @spec end_of_month(DateTime.t()) :: DateTime.t()
+  def end_of_month(dt) do
+    Timex.end_of_month(dt)
+  end
+
+  @spec end_of_year(Date.t()) :: Date.t()
+  def end_of_year(t) do
+    Timex.end_of_year(t)
+  end
+
+  @spec humanize(DateTime.t()) :: String.t()
+  def humanize(%DateTime{} = dt) do
+    Timex.Format.DateTime.Formatters.Relative.format!(dt, "{relative}")
+  end
+
+  @spec humanize_seconds(pos_integer()) :: String.t()
+  def humanize_seconds(seconds) do
+    seconds
+    |> Timex.Duration.from_seconds()
+    |> Timex.format_duration(Timex.Format.Duration.Formatters.Humanized)
+  end
+end

lib/plausible/timezones.ex

@@ -1,4 +1,13 @@
 defmodule Plausible.Timezones do
+  @moduledoc """
+  API for working with timezones wrapping around external libraries where necessary.
+  """
+
+  @spec valid?(String.t()) :: boolean()
+  def valid?(tz) do
+    Timex.is_valid_timezone?(tz)
+  end
+
   @spec options(DateTime.t()) :: [{:key, String.t()}, {:value, String.t()}, {:offset, integer()}]
   def options(now \\ DateTime.utc_now()) do
     Tzdata.zone_list()

lib/plausible_web/controllers/api/stats_controller.ex

@@ -148,15 +148,15 @@ defmodule PlausibleWeb.Api.StatsController do
          labels
        ) do
     date_range = Query.date_range(query)
-    build_intervals(labels, date_range, &Timex.beginning_of_week/1, &Timex.end_of_week/1)
+    build_intervals(labels, date_range, &Date.beginning_of_week/1, &Date.end_of_week/1)
   end
 
   defp build_full_intervals(
          %Query{interval: "month"} = query,
          labels
        ) do
     date_range = Query.date_range(query)
-    build_intervals(labels, date_range, &Timex.beginning_of_month/1, &Timex.end_of_month/1)
+    build_intervals(labels, date_range, &Date.beginning_of_month/1, &Date.end_of_month/1)
   end
 
   defp build_full_intervals(_query, _labels) do
@@ -243,7 +243,7 @@ defmodule PlausibleWeb.Api.StatsController do
       "day" ->
         current_date =
           DateTime.now!(site.timezone)
-          |> Timex.to_date()
+          |> DateTime.to_date()
           |> Date.to_string()
 
         Enum.find_index(dates, &(&1 == current_date))
@@ -253,7 +253,7 @@ defmodule PlausibleWeb.Api.StatsController do
 
         current_date =
           DateTime.now!(site.timezone)
-          |> Timex.to_date()
+          |> DateTime.to_date()
           |> Time.date_or_weekstart(date_range)
           |> Date.to_string()
 
@@ -262,8 +262,8 @@ defmodule PlausibleWeb.Api.StatsController do
       "month" ->
         current_date =
           DateTime.now!(site.timezone)
-          |> Timex.to_date()
-          |> Timex.beginning_of_month()
+          |> DateTime.to_date()
+          |> Date.beginning_of_month()
           |> Date.to_string()
 
         Enum.find_index(dates, &(&1 == current_date))

lib/plausible_web/email.ex

@@ -487,10 +487,7 @@ defmodule PlausibleWeb.Email do
   def export_success(user, site, expires_at) do
     expires_in =
       if expires_at do
-        Timex.Format.DateTime.Formatters.Relative.format!(
-          expires_at,
-          "{relative}"
-        )
+        Plausible.Times.humanize(expires_at)
       end
 
     download_url =

lib/plausible_web/live/csv_export.ex

@@ -188,7 +188,7 @@ defmodule PlausibleWeb.Live.CSVExport do
     <p :if={@export.expires_at} class="text-sm">
       Note: this file will expire
       <.hint message={@export.expires_at}>
-        {Timex.Format.DateTime.Formatters.Relative.format!(@export.expires_at, "{relative}")}.
+        {Plausible.Times.humanize(@export.expires_at)}.
       </.hint>
     </p>
 

lib/plausible_web/live/csv_import.ex

@@ -311,7 +311,7 @@ defmodule PlausibleWeb.Live.CSVImport do
           native_stats_start_date: native_stats_start_date
         } = socket.assigns
 
-        cutoff_date = native_stats_start_date || Timex.today(site.timezone)
+        cutoff_date = native_stats_start_date || Plausible.Times.today(site.timezone)
 
         case Imported.clamp_dates(occupied_ranges, cutoff_date, start_date, end_date) do
           {:ok, start_date, end_date} -> Date.range(start_date, end_date)

lib/workers/schedule_email_reports.ex

@@ -52,7 +52,7 @@ defmodule Plausible.Workers.ScheduleEmailReports do
   def monday_9am(timezone) do
     DateTime.now!(timezone)
     |> DateTime.shift(week: 1)
-    |> Timex.beginning_of_week()
+    |> Plausible.Times.beginning_of_week()
     |> DateTime.shift(hour: 9)
   end
 
@@ -93,7 +93,7 @@ defmodule Plausible.Workers.ScheduleEmailReports do
   def first_of_month_9am(timezone) do
     DateTime.now!(timezone)
     |> DateTime.shift(month: 1)
-    |> Timex.beginning_of_month()
+    |> Plausible.Times.beginning_of_month()
     |> DateTime.shift(hour: 9)
   end
 end

test/plausible/auth/totp_test.exs

@@ -330,7 +330,12 @@ defmodule Plausible.Auth.TOTPTest do
 
       assert {:ok, user} = TOTP.validate_code(user, new_code, allow_reuse?: true)
 
-      assert_in_delta Timex.to_unix(user.totp_last_used_at), System.os_time(:second), 2
+      totp_last_used_at =
+        user.totp_last_used_at
+        |> DateTime.from_naive!("Etc/UTC")
+        |> DateTime.to_unix()
+
+      assert_in_delta totp_last_used_at, System.os_time(:second), 2
     end
 
     test "fails when trying to reuse the same code twice" do