10 datetime param illegal

.gitignore

@@ -128,4 +128,7 @@ logs/
 *.py[co]
 __pycache__
 .pytest_cache
-*.egg-info
+*.egg-info
+
+# agent related
+.agent-notes/

lib/bolty/bolt_protocol/message/run_message.ex

@@ -2,22 +2,25 @@ defmodule Bolty.BoltProtocol.Message.RunMessage do
   @moduledoc false
 
   alias Bolty.BoltProtocol.MessageEncoder
+  alias Bolty.Policy
 
   @signature 0x10
 
-  def encode(bolt_version, query, parameters, extra_parameters)
+  def encode(bolt_version, query, parameters, extra_parameters, policy \\ %Policy{})
+
+  def encode(bolt_version, query, parameters, extra_parameters, policy)
       when is_float(bolt_version) and bolt_version >= 3.0 do
     message = [query, parameters, get_extra_parameters(extra_parameters)]
-    MessageEncoder.encode(@signature, message)
+    MessageEncoder.encode(@signature, message, policy)
   end
 
-  def encode(bolt_version, query, parameters, _extra_parameters)
+  def encode(bolt_version, query, parameters, _extra_parameters, policy)
       when is_float(bolt_version) and bolt_version <= 2.0 do
     message = [query, parameters]
-    MessageEncoder.encode(@signature, message)
+    MessageEncoder.encode(@signature, message, policy)
   end
 
-  def encode(_, _, _, _) do
+  def encode(_, _, _, _, _) do
     {:error,
      Bolty.Error.wrap(__MODULE__, %{
        code: :unsupported_message_version,

lib/bolty/bolt_protocol/message_encoder.ex

@@ -2,47 +2,48 @@ defmodule Bolty.BoltProtocol.MessageEncoder do
   @moduledoc false
 
   alias Bolty.PackStream
+  alias Bolty.Policy
 
   @max_chunk_size 65_535
   @end_marker <<0x00, 0x00>>
   @tiny_struct_marker 0xB
   @struct8_marker 0xDC
   @struct16_marker 0xDD
 
-  def encode(signature, data) do
+  def encode(signature, data, policy \\ %Policy{}) do
     Bolty.Utils.Logger.log_message(:client, :message_type, data)
 
     encoded =
       signature
-      |> do_encode(data)
+      |> do_encode(data, policy)
       |> generate_chunks([])
 
     Bolty.Utils.Logger.log_message(:client, :message_type, encoded, :hex)
     encoded |> IO.iodata_to_binary()
   end
 
-  defp do_encode(signature, list) when length(list) <= 15 do
+  defp do_encode(signature, list, policy) when length(list) <= 15 do
     [
       <<@tiny_struct_marker::4, length(list)::4, signature>>,
-      encode_list_data(list)
+      encode_list_data(list, policy)
     ]
   end
 
-  defp do_encode(signature, list) when length(list) <= 255 do
-    [<<@struct8_marker::8, length(list)::8, signature>>, encode_list_data(list)]
+  defp do_encode(signature, list, policy) when length(list) <= 255 do
+    [<<@struct8_marker::8, length(list)::8, signature>>, encode_list_data(list, policy)]
   end
 
-  defp do_encode(signature, list) when length(list) <= 65_535 do
+  defp do_encode(signature, list, policy) when length(list) <= 65_535 do
     [
       <<@struct16_marker::8, length(list)::16, signature>>,
-      encode_list_data(list)
+      encode_list_data(list, policy)
     ]
   end
 
-  defp encode_list_data(data) do
+  defp encode_list_data(data, policy) do
     Enum.map(
       data,
-      &PackStream.pack!(&1)
+      &PackStream.pack!(&1, policy)
     )
   end
 

lib/bolty/client.ex

@@ -27,7 +27,7 @@ defmodule Bolty.Client do
     LogoffMessage
   }
 
-  defstruct [:sock, :bolt_version]
+  defstruct [:sock, :bolt_version, policy: %Bolty.Policy{}]
 
   defmodule Config do
     @moduledoc false
@@ -282,7 +282,8 @@ defmodule Bolty.Client do
   end
 
   def send_run(client, query, parameters, extra_parameters) do
-    payload = RunMessage.encode(client.bolt_version, query, parameters, extra_parameters)
+    payload =
+      RunMessage.encode(client.bolt_version, query, parameters, extra_parameters, client.policy)
 
     with :ok <- send_packet(client, payload) do
       recv_packets(client, &RunMessage.prepare_messages/2, :infinity)

lib/bolty/connection.ex

@@ -5,14 +5,16 @@ defmodule Bolty.Connection do
   import Bolty.BoltProtocol.ServerResponse
 
   alias Bolty.Client
+  alias Bolty.Policy
   alias Bolty.Response
 
   defstruct [
     :client,
     :server_version,
     :hints,
     :patch_bolt,
-    :connection_id
+    :connection_id,
+    :policy
   ]
 
   @impl true
@@ -21,8 +23,9 @@ defmodule Bolty.Connection do
 
     with {:ok, %Client{} = client} <- Client.connect(config),
          {:ok, response_server_metadata} <- do_init(client, opts) do
+      policy = Policy.Resolver.resolve(client.bolt_version, response_server_metadata)
       state = get_server_metadata_state(response_server_metadata)
-      {:ok, %__MODULE__{state | client: client}}
+      {:ok, %__MODULE__{state | client: %{client | policy: policy}, policy: policy}}
     end
   end
 

lib/bolty/error.ex

@@ -18,13 +18,14 @@ defmodule Bolty.Error do
   @spec wrap(module(), atom()) :: t()
   def wrap(module, code) when is_atom(code), do: %__MODULE__{module: module, code: code}
 
-  @spec wrap(module(), binary()) :: t()
+  @spec wrap(module(), String.t()) :: t()
   def wrap(module, code) when is_binary(code), do: wrap(module, to_atom(code))
 
   @spec wrap(module(), map()) :: t()
   def wrap(module, bolt_error) when is_map(bolt_error),
     do: %__MODULE__{module: module, code: bolt_error.code |> to_atom(), bolt: bolt_error}
 
+  @spec wrap(any(), any(), any()) :: t()
   def wrap(module, code, packstream),
     do: %__MODULE__{module: module, code: code, packstream: packstream}
 
@@ -47,7 +48,7 @@ defmodule Bolty.Error do
   @doc """
   Gets the corresponding atom based on the error code.
   """
-  @spec to_atom(t()) :: String.t()
+  @spec to_atom(String.t()) :: atom()
   def to_atom(error_message) do
     Map.get(@error_map, error_message, :unknown)
   end

lib/bolty/pack_stream.ex

@@ -3,12 +3,13 @@ defmodule Bolty.PackStream do
 
   alias Bolty.PackStream.Packer
   alias Bolty.PackStream.Unpacker
+  alias Bolty.Policy
 
-  def pack(term, options \\ []) do
+  def pack(term, policy \\ %Policy{}, options \\ []) do
     iodata? = Keyword.get(options, :iodata, false)
 
     try do
-      Packer.pack(term)
+      Packer.pack(term, policy)
     catch
       :throw, error ->
         {:error, error}
@@ -24,9 +25,9 @@ defmodule Bolty.PackStream do
     end
   end
 
-  @spec pack!(term, Keyword.t()) :: iodata | no_return
-  def pack!(term, options \\ []) do
-    case pack(term, options) do
+  @spec pack!(term, Policy.t(), Keyword.t()) :: iodata | no_return
+  def pack!(term, policy \\ %Policy{}, options \\ []) do
+    case pack(term, policy, options) do
       {:ok, result} ->
         result
 
@@ -35,7 +36,7 @@ defmodule Bolty.PackStream do
     end
   end
 
-  @spec unpack(binary()) :: list()
+  @spec unpack(any()) :: {:error, any()} | {:ok, list()}
   def unpack(iodata) do
     try do
       iodata