From e465e22612df00ff9bca0dd4d29deb0a7bb62ccc Mon Sep 17 00:00:00 2001
From: Alexandre de Souza <alexandre@aledsz.com.br>
Date: Wed, 17 Jun 2026 16:51:38 -0300
Subject: [PATCH 1/3] Deprecate `ReqAthena`

---
 lib/assets/connection_cell/main.js    | 114 --------------------------
 lib/assets/sql_cell/main.js           |  20 -----
 lib/kino_db.ex                        |   1 -
 lib/kino_db/connection_cell.ex        |  65 +--------------
 lib/kino_db/sql_cell.ex               |   9 --
 mix.exs                               |   1 -
 test/kino_db/connection_cell_test.exs |  93 ---------------------
 test/kino_db/sql_cell_test.exs        |  84 -------------------
 8 files changed, 1 insertion(+), 386 deletions(-)

diff --git a/lib/assets/connection_cell/main.js b/lib/assets/connection_cell/main.js
index 7cfb8fd..6289a6f 100644
--- a/lib/assets/connection_cell/main.js
+++ b/lib/assets/connection_cell/main.js
@@ -538,113 +538,6 @@ export function init(ctx, info) {
     `,
   };
 
-  const AthenaForm = {
-    name: "AthenaForm",
-
-    components: {
-      BaseInput: BaseInput,
-      BaseSecret: BaseSecret,
-    },
-
-    props: {
-      fields: {
-        type: Object,
-        default: {},
-      },
-      helpBox: {
-        type: String,
-        default: "",
-      },
-      hasAwsCredentials: {
-        type: Boolean,
-        default: false,
-      },
-    },
-
-    methods: {
-      areFieldsEmpty(currentField, otherField) {
-        if (currentField === "" && otherField === "") {
-          return true;
-        }
-
-        return false;
-      },
-    },
-
-    template: `
-    <div class="row mixed-row">
-      <BaseInput
-        name="access_key_id"
-        label="Access Key ID"
-        type="text"
-        v-model="fields.access_key_id"
-        inputClass="input"
-        :grow
-        :required="!hasAwsCredentials"
-      />
-      <BaseSecret
-        textInputName="secret_access_key"
-        secretInputName="secret_access_key_secret"
-        toggleInputName="use_secret_access_key_secret"
-        label="Secret Access Key"
-        v-model:textInputValue="fields.secret_access_key"
-        v-model:secretInputValue="fields.secret_access_key_secret"
-        v-model:toggleInputValue="fields.use_secret_access_key_secret"
-        modalTitle="Set secret access key"
-      />
-    </div>
-    <div class="row mixed-row">
-      <BaseInput
-        name="token"
-        label="Session Token"
-        type="password"
-        v-model="fields.token"
-        inputClass="input"
-        :grow
-      />
-      <BaseInput
-        name="region"
-        label="Region"
-        type="text"
-        v-model="fields.region"
-        inputClass="input"
-        :grow
-        :required="!hasAwsCredentials"
-      />
-    </div>
-    <div class="row mixed-row">
-      <BaseInput
-        name="database"
-        label="Database"
-        type="text"
-        v-model="fields.database"
-        inputClass="input"
-        :grow
-        :required
-      />
-      <BaseInput
-        name="workgroup"
-        label="Workgroup"
-        type="text"
-        v-model="fields.workgroup"
-        inputClass="input"
-        :grow
-        :required="!!areFieldsEmpty(fields.workgroup, fields.output_location)"
-      />
-      <BaseInput
-        name="output_location"
-        label="Output Location"
-        type="url"
-        v-model="fields.output_location"
-        inputClass="input"
-        :grow
-        :required="!!areFieldsEmpty(fields.output_location, fields.workgroup)"
-      />
-    </div>
-    <small class="help-box" v-if="hasAwsCredentials" v-html="helpBox" />
-    `,
-  };
-
   const BigQueryForm = {
     name: "BigQueryForm",
 
@@ -950,7 +843,6 @@ export function init(ctx, info) {
       DefaultSQLForm: DefaultSQLForm,
       SQLServerForm: SQLServerForm,
       BigQueryForm: BigQueryForm,
-      AthenaForm: AthenaForm,
       ClickhouseForm: ClickhouseForm,
     },
 
@@ -988,7 +880,6 @@ export function init(ctx, info) {
           <SnowflakeForm v-bind:fields="fields" v-if="isSnowflake" />
           <ClickhouseForm v-bind:fields="fields" v-if="isClickhouse" />
           <BigQueryForm v-bind:fields="fields" v-bind:helpBox="helpBox" v-if="isBigQuery" />
-          <AthenaForm v-bind:fields="fields" v-bind:helpBox="helpBox" v-bind:hasAwsCredentials="hasAwsCredentials" v-if="isAthena" />
           <SQLServerForm v-bind:fields="fields" v-if="isSQLServer" />
           <DefaultSQLForm v-bind:fields="fields" v-if="isDefaultDatabase" />
         </div>
@@ -1008,7 +899,6 @@ export function init(ctx, info) {
           { label: "SQLite", value: "sqlite" },
           { label: "DuckDB", value: "duckdb" },
           { label: "Google BigQuery", value: "bigquery" },
-          { label: "AWS Athena", value: "athena" },
           { label: "Snowflake", value: "snowflake" },
           { label: "Clickhouse", value: "clickhouse" },
           { label: "SQL Server", value: "sqlserver" },
@@ -1037,10 +927,6 @@ export function init(ctx, info) {
         return this.fields.type === "bigquery";
       },
 
-      isAthena() {
-        return this.fields.type === "athena";
-      },
-
       isSQLServer() {
         return this.fields.type === "sqlserver";
       },
diff --git a/lib/assets/sql_cell/main.js b/lib/assets/sql_cell/main.js
index d5ee136..f62d375 100644
--- a/lib/assets/sql_cell/main.js
+++ b/lib/assets/sql_cell/main.js
@@ -228,14 +228,6 @@ export function init(ctx, payload) {
             inputClass="input input--xs"
             :inline
           />
-          <BaseSwitch
-            v-if="hasCache"
-            @change="handleCacheQueryChange"
-            name="cache_query"
-            label="Cache"
-            v-model="payload.cache_query"
-            :inline
-          />
           <div class="grow"></div>
           <button id="help-toggle" @click="toggleHelpBox" class="icon-button">
             <i class="ri ri-questionnaire-line" aria-hidden="true"></i>
@@ -260,7 +252,6 @@ export function init(ctx, payload) {
           mysql: "MySQL",
           sqlite: "SQLite",
           bigquery: "Google BigQuery",
-          athena: "AWS Athena",
           snowflake: "Snowflake",
           sqlserver: "SQL Server",
           duckdb: "DuckDB",
@@ -295,9 +286,6 @@ export function init(ctx, payload) {
           ]);
         }
       },
-      hasCache() {
-        return this.payload.connection?.type === 'athena';
-      },
       hasTimeout() {
         const hasTimeout = ["postgres", "mysql", "sqlite", "sqlserver"];
         return hasTimeout.includes(this.payload.connection?.type);
@@ -321,10 +309,6 @@ export function init(ctx, payload) {
         ctx.pushEvent("update_result_variable", value);
       },
 
-      handleCacheQueryChange({ target: { checked } }) {
-        ctx.pushEvent("update_cache_query", checked);
-      },
-
       handleTimeoutChange({ target: { value } }) {
         ctx.pushEvent("update_timeout", value);
       },
@@ -354,10 +338,6 @@ export function init(ctx, payload) {
     app.payload.connection = connection;
   });
 
-  ctx.handleEvent("update_cache_query", (value) => {
-    app.payload.cache_query = value;
-  });
-
   ctx.handleEvent("update_timeout", (timeout) => {
     app.payload.timeout = timeout;
   });
diff --git a/lib/kino_db.ex b/lib/kino_db.ex
index 0c89bda..9904c07 100644
--- a/lib/kino_db.ex
+++ b/lib/kino_db.ex
@@ -3,7 +3,6 @@ results = [
   MyXQL.Result,
   Exqlite.Result,
   ReqBigQuery.Result,
-  ReqAthena.Result,
   Tds.Result,
   Adbc.Result
 ]
diff --git a/lib/kino_db/connection_cell.ex b/lib/kino_db/connection_cell.ex
index 8a1db7d..663a953 100644
--- a/lib/kino_db/connection_cell.ex
+++ b/lib/kino_db/connection_cell.ex
@@ -54,8 +54,6 @@ defmodule KinoDB.ConnectionCell do
       "private_key_passphrase_secret" => attrs["private_key_passphrase_secret"] || "",
       "token" => attrs["token"] || "",
       "region" => attrs["region"] || "us-east-1",
-      "workgroup" => attrs["workgroup"] || "",
-      "output_location" => attrs["output_location"] || "",
       "account" => attrs["account"] || "",
       "schema" => attrs["schema"] || "",
       "warehouse" => attrs["warehouse"] || "",
@@ -144,13 +142,6 @@ defmodule KinoDB.ConnectionCell do
         "bigquery" ->
           ~w|project_id default_dataset_id credentials_json|
 
-        "athena" ->
-          if fields["use_secret_access_key_secret"],
-            do:
-              ~w|access_key_id secret_access_key_secret token region workgroup output_location database|,
-            else:
-              ~w|access_key_id secret_access_key token region workgroup output_location database|
-
         "snowflake" ->
           snowflake_fields(fields)
 
@@ -215,15 +206,6 @@ defmodule KinoDB.ConnectionCell do
         "bigquery" ->
           ~w|project_id|
 
-        "athena" ->
-          if Code.ensure_loaded?(:aws_credentials),
-            do: ~w|database|,
-            else:
-              if(Map.has_key?(attrs, "secret_access_key"),
-                do: ~w|access_key_id secret_access_key region database|,
-                else: ~w|access_key_id secret_access_key_secret region database|
-              )
-
         "snowflake" ->
           snowflake_source_required_keys(attrs)
 
@@ -237,14 +219,7 @@ defmodule KinoDB.ConnectionCell do
           ~w|hostname port|
       end
 
-    conditional_keys =
-      case attrs["type"] do
-        "athena" -> ~w|workgroup output_location|
-        _ -> []
-      end
-
-    if all_fields_filled?(attrs, required_keys) and
-         any_fields_filled?(attrs, conditional_keys) do
+    if all_fields_filled?(attrs, required_keys) do
       attrs |> to_quoted() |> Kino.SmartCell.quoted_to_string()
     else
       ""
@@ -269,12 +244,6 @@ defmodule KinoDB.ConnectionCell do
     not Enum.any?(keys, fn key -> attrs[key] in [nil, ""] end)
   end
 
-  defp any_fields_filled?(_, []), do: true
-
-  defp any_fields_filled?(attrs, keys) do
-    Enum.any?(keys, fn key -> attrs[key] not in [nil, ""] end)
-  end
-
   defp trim_opts(opts) do
     Enum.map(opts, fn
       {key, value} when is_binary(value) -> {key, String.trim(value)}
@@ -377,24 +346,6 @@ defmodule KinoDB.ConnectionCell do
     end
   end
 
-  defp to_quoted(%{"type" => "athena"} = attrs) do
-    quote do
-      unquote(quoted_var(attrs["variable"])) =
-        ReqAthena.new(
-          access_key_id: unquote(attrs["access_key_id"]),
-          database: unquote(attrs["database"]),
-          output_location: unquote(attrs["output_location"]),
-          region: unquote(attrs["region"]),
-          secret_access_key: unquote(quoted_access_key(attrs)),
-          token: unquote(attrs["token"]),
-          workgroup: unquote(attrs["workgroup"]),
-          http_errors: :raise
-        )
-
-      :ok
-    end
-  end
-
   defp to_quoted(%{"type" => "clickhouse"} = attrs) do
     trimmed = attrs |> trim_opts() |> Map.new()
     shared_opts = shared_options(trimmed)
@@ -607,7 +558,6 @@ defmodule KinoDB.ConnectionCell do
       Code.ensure_loaded?(Postgrex) -> "postgres"
       Code.ensure_loaded?(MyXQL) -> "mysql"
       Code.ensure_loaded?(Exqlite) -> "sqlite"
-      Code.ensure_loaded?(ReqAthena) -> "athena"
       Code.ensure_loaded?(ReqCH) -> "clickhouse"
       Code.ensure_loaded?(Adbc) -> adbc_default_db_type()
       Code.ensure_loaded?(Tds) -> "sqlserver"
@@ -639,13 +589,6 @@ defmodule KinoDB.ConnectionCell do
     end
   end
 
-  defp missing_dep(%{"type" => "athena"}) do
-    missing_many_deps([
-      {ReqAthena, ~s|{:req_athena, "~> 0.3"}|},
-      {Explorer, ~s|{:explorer, "~> 0.10"}|}
-    ])
-  end
-
   defp missing_dep(%{"type" => adbc}) when adbc in ~w[duckdb snowflake bigquery] do
     unless Code.ensure_loaded?(Adbc) do
       ~s|{:adbc, "~> 0.3"}|
@@ -685,12 +628,6 @@ defmodule KinoDB.ConnectionCell do
     end
   end
 
-  defp help_box(%{"type" => "athena"}) do
-    if Code.ensure_loaded?(:aws_credentials) do
-      "You must fill in the fields above accordingly or authenticate your machine with AWS CLI authentication."
-    end
-  end
-
   defp help_box(_ctx), do: nil
 
   defp running_on_google_metadata? do
diff --git a/lib/kino_db/sql_cell.ex b/lib/kino_db/sql_cell.ex
index fccf3fa..be91ccf 100644
--- a/lib/kino_db/sql_cell.ex
+++ b/lib/kino_db/sql_cell.ex
@@ -160,7 +160,6 @@ defmodule KinoDB.SQLCell do
 
   defp connection_type(connection) when is_struct(connection, Req.Request) do
     cond do
-      Keyword.has_key?(connection.request_steps, :athena_run) -> "athena"
       Keyword.has_key?(connection.request_steps, :clickhouse_run) -> "clickhouse"
       true -> nil
     end
@@ -227,10 +226,6 @@ defmodule KinoDB.SQLCell do
   end
 
   # Req-based
-  defp to_quoted(%{"connection" => %{"type" => "athena"}} = attrs) do
-    to_quoted_req_query(attrs, quote(do: ReqAthena), fn _n -> "?" end)
-  end
-
   defp to_quoted(%{"connection" => %{"type" => "clickhouse"}} = attrs) do
     to_quoted_req_query(attrs, quote(do: ReqCH), fn n, inner ->
       name =
@@ -312,10 +307,6 @@ defmodule KinoDB.SQLCell do
        when timeout != nil and type in @connection_types_with_timeout,
        do: [[timeout: timeout * 1000]]
 
-  defp query_opts_args(%{"connection" => %{"type" => "athena"}} = attrs) do
-    [[format: :explorer] ++ if(attrs["cache_query"], do: [], else: [cache_query: false])]
-  end
-
   defp query_opts_args(%{"connection" => %{"type" => "clickhouse"}}),
     do: [[format: :explorer]]
 
diff --git a/mix.exs b/mix.exs
index de9fa39..dc3c2fe 100644
--- a/mix.exs
+++ b/mix.exs
@@ -36,7 +36,6 @@ defmodule KinoDB.MixProject do
       {:tds, "~> 2.3.4 or ~> 2.4", optional: true},
 
       # Those dependecies are new, so we use stricter versions
-      {:req_athena, "~> 0.3.0", optional: true},
       {:req_ch, "~> 0.1.0", optional: true},
 
       # Dev only
diff --git a/test/kino_db/connection_cell_test.exs b/test/kino_db/connection_cell_test.exs
index 87552ce..1915009 100644
--- a/test/kino_db/connection_cell_test.exs
+++ b/test/kino_db/connection_cell_test.exs
@@ -162,42 +162,6 @@ defmodule KinoDB.ConnectionCellTest do
              {:ok, db} = Kino.start_child({Exqlite, opts})\
              '''
 
-      assert ConnectionCell.to_source(put_in(@attrs["type"], "athena")) == ~s'''
-             db =
-               ReqAthena.new(
-                 access_key_id: "id",
-                 database: "default",
-                 output_location: "s3://my-bucket",
-                 region: "region",
-                 secret_access_key: "secret",
-                 token: "token",
-                 workgroup: "primary",
-                 http_errors: :raise
-               )
-
-             :ok\
-             '''
-
-      attrs =
-        Map.delete(@attrs, "secret_access_key")
-        |> Map.merge(%{"type" => "athena", "secret_access_key_secret" => "ATHENA_KEY"})
-
-      assert ConnectionCell.to_source(attrs) == ~s'''
-             db =
-               ReqAthena.new(
-                 access_key_id: "id",
-                 database: "default",
-                 output_location: "s3://my-bucket",
-                 region: "region",
-                 secret_access_key: System.fetch_env!("LB_ATHENA_KEY"),
-                 token: "token",
-                 workgroup: "primary",
-                 http_errors: :raise
-               )
-
-             :ok\
-             '''
-
       attrs =
         Map.delete(@attrs, "password_secret")
         |> Map.merge(%{"variable" => "conn", "auth_type" => "auth_snowflake"})
@@ -302,16 +266,9 @@ defmodule KinoDB.ConnectionCellTest do
       assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "mysql")) == ""
       assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "sqlite")) == ""
       assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "bigquery")) == ""
-      assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "athena")) == ""
       assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "snowflake")) == ""
       assert ConnectionCell.to_source(put_in(@empty_required_fields["type"], "clickhouse")) == ""
     end
-
-    test "generates empty source code when all conditional fields are missing" do
-      attrs = Map.merge(@attrs, %{"type" => "athena", "workgroup" => "", "output_location" => ""})
-
-      assert ConnectionCell.to_source(attrs) == ""
-    end
   end
 
   test "when a field changes, broadcasts the change and sends source update" do
@@ -383,54 +340,4 @@ defmodule KinoDB.ConnectionCellTest do
       """
     )
   end
-
-  test "athena secret key from secrets" do
-    {kino, _source} =
-      start_smart_cell!(ConnectionCell, %{
-        "variable" => "conn",
-        "type" => "athena",
-        "database" => "default",
-        "access_key_id" => "id",
-        "secret_access_key" => "secret_key",
-        "token" => "token",
-        "region" => "region",
-        "output_location" => "s3://my-bucket",
-        "workgroup" => "primary"
-      })
-
-    push_event(kino, "update_field", %{"field" => "use_secret_access_key_secret", "value" => true})
-
-    assert_broadcast_event(kino, "update", %{
-      "fields" => %{"use_secret_access_key_secret" => true}
-    })
-
-    push_event(kino, "update_field", %{
-      "field" => "secret_access_key_secret",
-      "value" => "ATHENA_KEY"
-    })
-
-    assert_broadcast_event(kino, "update", %{
-      "fields" => %{"secret_access_key_secret" => "ATHENA_KEY"}
-    })
-
-    assert_smart_cell_update(
-      kino,
-      %{"secret_access_key_secret" => "ATHENA_KEY"},
-      """
-      conn =
-        ReqAthena.new(
-          access_key_id: "id",
-          database: "default",
-          output_location: "s3://my-bucket",
-          region: "region",
-          secret_access_key: System.fetch_env!("LB_ATHENA_KEY"),
-          token: "token",
-          workgroup: "primary",
-          http_errors: :raise
-        )
-
-      :ok\
-      """
-    )
-  end
 end
diff --git a/test/kino_db/sql_cell_test.exs b/test/kino_db/sql_cell_test.exs
index fc4725d..5e821e7 100644
--- a/test/kino_db/sql_cell_test.exs
+++ b/test/kino_db/sql_cell_test.exs
@@ -115,11 +115,6 @@ defmodule KinoDB.SQLCellTest do
              result = Adbc.Connection.query!(conn, ~S"SELECT id FROM users", [])\
              """
 
-      assert SQLCell.to_source(put_in(attrs["connection"]["type"], "athena")) == """
-             result = ReqAthena.query!(conn, ~S"SELECT id FROM users", [], format: :explorer).body
-             Kino.DataTable.new(result)\
-             """
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "snowflake")) == """
              result = Adbc.Connection.query!(conn, ~S"SELECT id FROM users", [])\
              """
@@ -192,21 +187,6 @@ defmodule KinoDB.SQLCellTest do
                )\
              '''
 
-      assert SQLCell.to_source(put_in(attrs["connection"]["type"], "athena")) == ~s'''
-             result =
-               ReqAthena.query!(
-                 conn,
-                 ~S"""
-                 SELECT id FROM users
-                 WHERE last_name = 'Sherlock'
-                 """,
-                 [],
-                 format: :explorer
-               ).body
-
-             Kino.DataTable.new(result)\
-             '''
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "snowflake")) == ~s'''
              result =
                Adbc.Connection.query!(
@@ -289,18 +269,6 @@ defmodule KinoDB.SQLCellTest do
                ])\
              '''
 
-      assert SQLCell.to_source(put_in(attrs["connection"]["type"], "athena")) == ~s'''
-             result =
-               ReqAthena.query!(
-                 conn,
-                 ~S"SELECT id FROM users WHERE id ? AND name LIKE ?",
-                 [user_id, search <> "%"],
-                 format: :explorer
-               ).body
-
-             Kino.DataTable.new(result)\
-             '''
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "snowflake")) == ~s'''
              result =
                Adbc.Connection.query!(conn, ~S"SELECT id FROM users WHERE id ?1 AND name LIKE ?2", [
@@ -396,22 +364,6 @@ defmodule KinoDB.SQLCellTest do
                )\
              '''
 
-      assert SQLCell.to_source(put_in(attrs["connection"]["type"], "athena")) == ~s'''
-             result =
-               ReqAthena.query!(
-                 conn,
-                 ~S"""
-                 SELECT id from users
-                 -- WHERE id = {{user_id1}}
-                 /* WHERE id = {{user_id2}} */ WHERE id = ?
-                 """,
-                 [user_id3],
-                 format: :explorer
-               ).body
-
-             Kino.DataTable.new(result)\
-             '''
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "snowflake")) == ~s'''
              result =
                Adbc.Connection.query!(
@@ -481,11 +433,6 @@ defmodule KinoDB.SQLCellTest do
              result = Adbc.Connection.query!(conn, ~S"SELECT id FROM users", [])\
              """
 
-      assert SQLCell.to_source(put_in(attrs["connection"]["type"], "athena")) == """
-             result = ReqAthena.query!(conn, ~S"SELECT id FROM users", [], format: :explorer).body
-             Kino.DataTable.new(result)\
-             """
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "snowflake")) == """
              result = Adbc.Connection.query!(conn, ~S"SELECT id FROM users", [])\
              """
@@ -533,23 +480,6 @@ defmodule KinoDB.SQLCellTest do
              result = Adbc.Connection.query!(conn, ~S"SELECT id FROM users", [])\
              """
 
-      athena = put_in(attrs["connection"]["type"], "athena")
-
-      assert SQLCell.to_source(put_in(athena["cache_query"], true)) == """
-             result = ReqAthena.query!(conn, ~S"SELECT id FROM users", [], format: :explorer).body
-             Kino.DataTable.new(result)\
-             """
-
-      assert SQLCell.to_source(put_in(athena["cache_query"], false)) == """
-             result =
-               ReqAthena.query!(conn, ~S"SELECT id FROM users", [],
-                 format: :explorer,
-                 cache_query: false
-               ).body
-
-             Kino.DataTable.new(result)\
-             """
-
       assert SQLCell.to_source(put_in(attrs["connection"]["type"], "sqlserver")) == """
              result = Tds.query!(conn, ~S"SELECT id FROM users", [])\
              """
@@ -569,20 +499,6 @@ defmodule KinoDB.SQLCellTest do
              result =
                Postgrex.query!(conn, ~S"SELECT id FROM users WHERE last_name = '\#{user_id}'", [])\
              """
-
-      athena = put_in(attrs["query"], "SELECT id FROM users\nWHERE last_name = '\#{user_id}'")
-
-      assert SQLCell.to_source(put_in(athena["cache_query"], true)) == ~s'''
-             result =
-               Postgrex.query!(
-                 conn,
-                 ~S"""
-                 SELECT id FROM users
-                 WHERE last_name = '\#{user_id}'
-                 """,
-                 []
-               )\
-             '''
     end
   end
 

From b258dc85740e56652036b572c8bd0eae49e571b1 Mon Sep 17 00:00:00 2001
From: Alexandre de Souza <alexandre@aledsz.com.br>
Date: Mon, 22 Jun 2026 16:22:42 -0300
Subject: [PATCH 2/3] Remove unused deps

---
 mix.lock | 2 --
 1 file changed, 2 deletions(-)

diff --git a/mix.lock b/mix.lock
index 120c687..0496900 100644
--- a/mix.lock
+++ b/mix.lock
@@ -23,9 +23,7 @@
   "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},
   "postgrex": {:hex, :postgrex, "0.18.0", "f34664101eaca11ff24481ed4c378492fed2ff416cd9b06c399e90f321867d7e", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "a042989ba1bc1cca7383ebb9e461398e3f89f868c92ce6671feb7ef132a252d1"},
   "req": {:hex, :req, "0.5.15", "662020efb6ea60b9f0e0fac9be88cd7558b53fe51155a2d9899de594f9906ba9", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "a6513a35fad65467893ced9785457e91693352c70b58bbc045b47e5eb2ef0c53"},
-  "req_athena": {:hex, :req_athena, "0.3.0", "aa063489fd9a4506f85b74b42e1b609b3525ad3c9bcd2e41f78763e14e867086", [:mix], [{:aws_credentials, "~> 0.2", [hex: :aws_credentials, repo: "hexpm", optional: true]}, {:explorer, "~> 0.9", [hex: :explorer, repo: "hexpm", optional: true]}, {:req, "~> 0.5.0", [hex: :req, repo: "hexpm", optional: false]}, {:req_s3, "~> 0.2", [hex: :req_s3, repo: "hexpm", optional: false]}], "hexpm", "646e4c659e4ad3532d8bd209651abb5f7c2db4c9e06aede1f0ee7bc04feb8b82"},
   "req_ch": {:hex, :req_ch, "0.1.0", "a8c8710b2fc51ff6bf43d3842bdaff8269688f62ae94250dcfa92d2d37ca4279", [:mix], [{:explorer, "~> 0.10", [hex: :explorer, repo: "hexpm", optional: true]}, {:req, "~> 0.5", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "7aad3e3f4492647b431294e1fbb915c7280af8628ec6104506029b376b2b4150"},
-  "req_s3": {:hex, :req_s3, "0.2.3", "ede5f4c792cf39995379307733ff4593032a876f38da29d9d7ea03881b498b51", [:mix], [{:req, "~> 0.5.6", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "31b5d52490495c8aeea7e3c5cbcec82f49035e11bdaf41f0e58ab716fefe44ca"},
   "table": {:hex, :table, "0.1.2", "87ad1125f5b70c5dea0307aa633194083eb5182ec537efc94e96af08937e14a8", [:mix], [], "hexpm", "7e99bc7efef806315c7e65640724bf165c3061cdc5d854060f74468367065029"},
   "tds": {:hex, :tds, "2.3.4", "534749dd9ef61af960fcafa9cbb7186d6d7b9f92ea0133fb25da07b121c8295c", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.9 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "bb9a53d4688a85fd566f342f76b50d39adfc4b410062886ef908365ead24ba3f"},
   "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},

From 8a728ac827f8ca29d97c1dcfd3f67f5170b42870 Mon Sep 17 00:00:00 2001
From: Alexandre de Souza <alexandre@aledsz.com.br>
Date: Mon, 22 Jun 2026 16:25:34 -0300
Subject: [PATCH 3/3] Remove warnings

---
 lib/kino_db/connection_cell.ex | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/lib/kino_db/connection_cell.ex b/lib/kino_db/connection_cell.ex
index 663a953..5b8ee39 100644
--- a/lib/kino_db/connection_cell.ex
+++ b/lib/kino_db/connection_cell.ex
@@ -359,16 +359,6 @@ defmodule KinoDB.ConnectionCell do
     end
   end
 
-  defp quoted_access_key(%{"secret_access_key" => password}), do: password
-
-  defp quoted_access_key(%{"secret_access_key_secret" => ""}), do: ""
-
-  defp quoted_access_key(%{"secret_access_key_secret" => secret}) do
-    quote do
-      System.fetch_env!(unquote("LB_#{secret}"))
-    end
-  end
-
   defp quoted_private_key(%{"private_key" => pk}), do: pk
 
   defp quoted_private_key(%{"private_key_secret" => ""}), do: ""