DEV Community: OnPoint Vietnam

[TIL] Reusable LiveView.JS commands with JS.exec

Dung Nguyen — Wed, 12 Jul 2023 14:43:13 +0000

This article was originally posted on https://bluzky.github.io/2023-07-12-til-reusable-liveview-js-commands-with-js-exec/

In this post I will build a simple dropdown for demo purpose. Not fully functional as a real dropdown :D.

1. Duplicated code

<div
  class="relative inline-block m-10"
  id="my-dropdown"
  phx-mounted={@open && (JS.show(to: "#my-dropdown .dropdown-content") |> JS.add_class("bg-blue-300", to: "#my-dropdown .dropdown-btn"))}
>
  <div
    class="dropdown-btn border border-gray-100 px-4 py-2 rounded-lg bg-gray-700 text-white inline-block cursor-pointer"
    phx-click={JS.show(to: "#my-dropdown .dropdown-content") |> JS.add_class("bg-blue-300", to: "#my-dropdown .dropdown-btn")}
  >
    Toggle button
  </div>
  <div class="dropdown-content absolute hidden bottom-0 left-0 translate-y-full w-[275px] bg-slate-50 rounded-lg border border-slate-200 shadow-md py-5">
    <div class="border-b hover:bg-slate-100 px-5 py-2">Item 1</div>
    <div class="border-b hover:bg-slate-100 px-5 py-2">Item 2</div>
    <div class="border-b hover:bg-slate-100 px-5 py-2">Item 3</div>
    <div class="border-b hover:bg-slate-100 px-5 py-2">Item 4</div>
    <div class="border-b hover:bg-slate-100 px-5 py-2">Item 5</div>
  </div>
</div>

2. Writing a function

To avoid duplicated JS code, you can write a function in LiveView component

def open_dropdown(id) do
    [to: "##{id} .dropdown-content"]
    |> JS.show()
    |> JS.add_class("bg-blue-300", to: "##{id} .dropdown-btn")
end

and update your template

<div
  class="relative inline-block m-10"
  id="my-dropdown"
  phx-mounted={@open && open_dropdown("my-dropdown")}
>
  <div
    class="dropdown-btn border border-gray-100 px-4 py-2 rounded-lg bg-gray-700 text-white inline-block cursor-pointer"
    phx-click={open_dropdown("my-dropdown")}
  >
    Toggle button
  </div>
  <div class="dropdown-content absolute hidden bottom-0 left-0 translate-y-full w-[275px] bg-slate-50 rounded-lg border border-slate-200 shadow-md py-5">
    <!-- Your dropdown content -->
  </div>
</div>

This way you write code in 2 separated modules and you have to switch between them to understand how it works.

3. Reuse code with `JS.exec`

JS.exec's document says:

Executes JS commands located in element attributes.

The followed example make me think that it only support some special attributes like phx-remote and phx-* attributes. Recently I found that it could be any attribute name.

The example above can be rewrite:

<div
  class="relative inline-block m-10"
  id="my-dropdown"
  action-open-dropdown={
    JS.show(to: "#my-dropdown .dropdown-content")
    |> JS.add_class("bg-blue-300", to: "#my-dropdown .dropdown-btn")
  }
  phx-mounted={@open && JS.exec("action-open-dropdown")}
>
  <div
    class="dropdown-btn border border-gray-100 px-4 py-2 rounded-lg bg-gray-700 text-white inline-block cursor-pointer"
    phx-click={JS.exec("action-open-dropdown", to: "#my-dropdown")}
  >
    Toggle button
  </div>
  <div class="dropdown-content absolute hidden bottom-0 left-0 translate-y-full w-[275px] bg-slate-50 rounded-lg border border-slate-200 shadow-md py-5">
    <!-- Your dropdown content -->
  </div>
</div>

This way you don't have to switch between files to get full implementation logic.

How to download large file in Elixir

Dung Nguyen — Sat, 08 Jan 2022 05:05:54 +0000

In my project, I have a quite large csv file for seeding my database. Put it is project source code increasing size of docker image but that file only run once. So I decide to upload to S3 and stream/download to server and then run seeding code. In this post I will show you how I do this.

I found some post which stream file using HTTPoison library but in some case I don't want to add more dependencies so I write my own module, and I think it's a good way to learn new things.

What you will learn

You will learn 2 cool function

Stream.resource to build a new stream
And :hackney.stream_body to read chunk of data from remote file

1. Build the stream

For Stream.resource, read full document here

Basically, this function receives 3 function as arguments: one function to setup stream, one for build data stream, and one for handle stream completion. This example from the hexdocs.pm

Stream.resource(
  fn -> File.open!("sample") end,
  fn file ->
    case IO.read(file, :line) do
      data when is_binary(data) -> {[data], file}
      _ -> {:halt, file}
    end
  end,
  fn file -> File.close(file) end
)

Fisrt function open the file and its result is passed as argument for second function
Second function read data line by line until the end of file
Third function handle close file handler

For downloading file, we do similar

Open the connection
Stream parts of file
Close connection

def stream_url(url) do
    Stream.resource(
      fn -> begin_download(url) end,
      &continue_download/1,
      &finish_download/1
    )
end

2. Open connection

defp begin_download(url) do
    {:ok, _status, headers, client} = :hackney.get(url)
    headers = Enum.into(headers, %{})
    total_size = headers["Content-Length"] |> String.to_integer()

    {client, total_size, 0} # 0 is current downloaded size
end

Here we:

Use :hackney.get to open connection to server
Extract content length from header, this is useful to verify length later
Return tuple of {client, total_size, current_download_size} these data would be used to stream content in the next function

3. Stream chunks

defp continue_download({client, total_size, size}) do
    case :hackney.stream_body(client) do
      {:ok, data} ->
        # update downloaded size
        new_size = size + byte_size(data)
        {[data], {client, total_size, new_size}}

      :done ->
         # no more data, tell stream to close
         # and move to function 3
        {:halt, {client, total_size, size}}

      {:error, reason} ->
        raise reason
    end
end

Here we use :hackney.stream_body to read data from connection chunk by chunk

4. Close connection

defp finish_download({client, total_size, size}) do
    :hackney.close(client)
    Logger.debug("Complete download #{size} / #{total_size} bytes")
end

Here we simply close the connection

5. Save to the file

In the above steps, we build a stream of data, now we save it to a file

def download(url, save_path) do
    stream_url(url)
    |> Stream.into(File.stream!(save_path))
    |> Stream.run()
end

Remember to invoke Stream.run to actually run the stream.

6. Stream by line

In our case, we don't want to store file on our server because we only use it once. So we stream and process file content on the fly. We use csv library to decode csv content because it supports stream but it only accepts stream of lines.

So here we transform stream of chunk to stream of line

def stream_url(url, :line) do
    stream_url(url)
    |> Stream.concat([:end]) # to known when the stream end
    |> Stream.transform("", fn
      :end, prev ->
        {[prev], ""}

      chunk, prev ->
        [last_line | lines] =
          String.split(prev <> chunk, "\n")
          |> Enum.reverse()

        {Enum.reverse(lines), last_line}
    end)
end

Details about why to split it like this you can read this post from poeticoding.com

References

Thanks for idea from https://gist.github.com/avdi/7990684
and poeticoding.com that help me to solve my problem.

Full source code here

Thanks for reading and your feedback are warmly welcome.

Build your own date time parser in Elixir

Dung Nguyen — Sat, 11 Dec 2021 16:48:02 +0000

Elixir does not have built-in date time parser function. In this post, I will show you how to create one using regex.
The idea is:

Define a format string
Build regex pattern from format string
Compile datetime string with regex pattern
Build datetime struct from extracted parts.

And we will have something like this:

Toolkit.DateTimeHelper.parse("18/12/21", "%d/%m/%y")
#> {:ok, ~U[2021-12-18 00:00:00Z]}

1. Define format string.

For simplicity, we support some basic format using convention from Calendar.strftime

format	description	value example
H	24 hour	00 - 23
I	12 hour	00 - 12
M	minute	00 - 59
S	second	00 - 59
d	day	01 - 31
m	month	01 -12
y	2 digits year	00 - 99
Y	4 digits year
z	timezone offset	+0100, -0330
Z	timezone name	UTC+7, Asia/Ho_Chi_Minh
p	PM or AM
P	pm or am

defmodule DateTimeParser do
    @mapping %{
    "H" => "(?<hour>\\d{2})",
    "I" => "(?<hour12>\\d{2})",
    "M" => "(?<minute>\\d{2})",
    "S" => "(?<second>\\d{2})",
    "d" => "(?<day>\\d{2})",
    "m" => "(?<month>\\d{2})",
    "y" => "(?<year2>\\d{2})",
    "Y" => "(?<year>-?\\d{4})",
    "z" => "(?<tz>[+-]?\\d{4})",
    "Z" => "(?<tz_name>[a-zA-Z_\/]+)",
    "p" => "(?<p>PM|AM)",
    "P" => "(?<P>pm|am)",
    "%" => "%"
  }
end

Here we define a mapping between format character and regex pattern. In the pattern we using named capture to assign name to matched content. This will help us handle datetime parts easier.

2. Build regex pattern from format string

def build_regex(format) do
  keys = Map.keys(@mapping) |> Enum.join("")

  Regex.compile!("([^%]*)%([#{keys}])([^%]*)")
  |> Regex.scan(format)
  |> Enum.map(fn [_, s1, key, s2] ->
    [s1, Map.get(@mapping, key), s2]
  end)
  |> to_string()
  |> Regex.compile!()
end

Here we scan for all string that start with % and followed by any of our format character which defined above.
And then for each matching, we do replace the format with appropriate regex string.
Finally we compile it to a regex struct.

3. Capture all required parts

This is the easiest part. Regex do this for us.

def parse(dt_string, format \\ "%Y-%m-%dT%H:%M:%SZ") do
  format
  |> build_regex
  |> Regex.named_captures(dt_string)
  |> cast_data()
  |> to_datetime()
end

cast_data and to_datetime are defined right belows, don't worry.

4. Build datetime struct from captured parts

This is the heavy part, we do it in 2 steps:

Cast and validate data
Build datetime struct

4.1 Cast and validate data

First we define some default values.

@default_value %{
    day: 1,
    month: 1,
    year: 0,
    hour: 0,
    minute: 0,
    second: 0,
    utc_offset: 0,
    tz_name: "UTC",
    shift: "AM"
}

Then for each captured parts, we cast and validate each one until completed or got an error.

def cast_data(nil), do: {:error, "invalid datetime"}

def cast_data(captures) do
    captures
    |> Enum.reduce_while([], fn {part, value}, acc ->
      case cast(part, value) do
        {:ok, data} -> {:cont, [data | acc]}
        {:error, _} = error -> {:halt, error}
      end
    end)
    |> case do
      {:error, _} = error -> error
      data -> Enum.into(data, @default_value)
    end
end

For each part we have different validation and logics.
For part of days, we do upcase to make them same value so we handle them same way later:

  defp cast("P", value) do
    cast("p", String.upcase(value))
  end

  defp cast("p", value) do
    {:ok, {:shift, value}}
  end

For timezone offset, we calculate :utc_offset in second. For timezone name, we keep it as is.

  defp cast("tz", value) do
    {hour, minute} = String.split_at(value, 3)

    with {:ok, {_, hour}} <- cast("offset_h", hour),
         {:ok, {_, minute}} <- cast("offset_m", minute) do
      sign = div(hour, abs(hour))
      {:ok, {:utc_offset, sign * (abs(hour) * 3600 + minute * 60)}}
    else
      _ -> {:error, "#{value} is invalid timezone offset"}
    end
  end

  defp cast("tz_name", value) do
    {:ok, {:tz_name, value}}
  end

For other parts, we convert to integer and check against valid range.
Let's define some validation ranges:

  @value_rages %{
    "hour" => [0, 23],
    "hour12" => [0, 12],
    "minute" => [0, 59],
    "second" => [0, 59],
    "day" => [0, 31],
    "month" => [1, 12],
    "year2" => [0, 99]
  }

  defp cast(part, value) do
    value = String.to_integer(value)

    valid =
      case Map.get(@value_rages, part) do
        [min, max] ->
          value >= min and value <= max

        _ ->
          true
      end

    if valid do
      {:ok, {String.to_atom(part), value}}
    else
      {:error, "#{value} is not a valid #{part}"}
    end
  end

4.2 Combine those all parts

For year with 2 digits, get 2 first digits of current year to make 4 digits year.

  defp to_datetime({:error, _} = error), do: error

  defp to_datetime(%{year2: value} = data) do
    current_year = DateTime.utc_now() |> Map.get(:year)
    year = div(current_year, 100) * 100 + value

    data
    |> Map.put(:year, year)
    |> Map.delete(:year2)
    |> to_datetime()
  end

For 12 hours format, we convert to 24 hours.

  defp to_datetime(%{hour12: hour} = data) do
    # 12AM is not valid

    if hour == 12 and data.shift == "AM" do
      {:error, "12AM is invalid value"}
    else
      hour =
        cond do
          hour == 12 and data.shift == "PM" -> hour
          data.shift == "AM" -> hour
          data.shift == "PM" -> hour + 12
        end

      data
      |> Map.put(:hour, hour)
      |> Map.delete(:hour12)
      |> to_datetime()
    end
  end

After handling special cases, we build Date, Time and combine them into DateTime struct and handle time zone name.

  defp to_datetime(data) do
    with {:ok, date} <- Date.new(data.year, data.month, data.day),
         {:ok, time} <- Time.new(data.hour, data.minute, data.second),
         {:ok, datetime} <- DateTime.new(date, time) do
      datetime = DateTime.add(datetime, -data.utc_offset, :second)

      if data.tz_name != "UTC" do
        DateTime.shift_zone(datetime, data.tz_name)
      else
        {:ok, datetime}
      end
    end
  end

Conclusion

There are many way to build datetime parser, but using regex, in my opinion, is simplest way and easiest to understand. You can build it yourself and add some more format, no need to add another dependency to your library.

You can see the fullsource code here on gist.

If you have any feedback or suggestion, leave me a comment.
Thanks for reading.

Installing Erlang & Elixir on M1 Macs

phathdt — Thu, 09 Dec 2021 16:59:26 +0000

This week I have a new macbook pro M1, an amazing computer. After several times install erlang and elixir with but dont have any luck. Then I have a solution is install erlang by brew, then reshim to asdf, this solution was suggested by this comment on GitHub

I assume you have installed asdf already, but here is the full installation command I use

brew install asdf autoconf wxmac openssl@1.1 fop coreutils automake libyaml readline libxslt libtool unixodbc unzip curl

Please note that you should install and using openssl@1.1 because Erlang doesn't support openssl 3 yet. If you already install the latest version, please try unlink and link version openssl@1.1

brew unlink openssl@3 
brew link openssl@1.1

Next is add plugin erlang asdf

asdf plugin add erlang https://github.com/asdf-vm/asdf-erlang.git

Now you are ready to install Erlang 24 and Elixir 1.12.3 using brew and reshim to asdf

brew install erlang@24 
cp -r /opt/homebrew/opt/erlang@24/lib/erlang ~/.asdf/installs/erlang/24.1.7
asdf reshim erlang 24.1.7
asdf global erlang 24.1.7 
asdf install elixir 1.12.3-otp-24
asdf global elixir 1.12.3-otp-24

to install another version ( 23 for me )

brew unlink erlang@24 
brew install erlang@23 
cp -r /opt/homebrew/opt/erlang@23/lib/erlang ~/.asdf/installs/erlang/23.3.4.9
asdf reshim erlang 23.3.4.9
asdf global erlang 23.3.4.9 
asdf install elixir 1.10.4-otp-23
asdf global elixir 1.10.4-otp-23

Please remember switch version erlang before install elixir

after these step, you can use asdf to switch version erlang instead of using brew

PS: you could check detail version erlang install brew at this
PS: you could try update to Mac Monterey, it will fix some issue with rosetta

Install old Erlang and Elixir version with asdf

Long Le — Mon, 15 Nov 2021 03:34:44 +0000

Last weekend, I installed old Erlang and Elixir version on my Mac and faced some issues that took me some time to research and resolve. I think I should share my experience here to help you saving your time if you encounter the same issues as me.
Firstly, what is asdf and how to install multiple versions of Erlang and Elixir using asdf. I read some posts that are really helpful but this one seems to be the best: https://thinkingelixir.com/install-elixir-using-asdf/

In summary, you need to do the following steps:

Install asdf (using homebrew, zsh plugin...).
Add erlang plugin to asdf. Asdf uses plugins to manage libraries.
Install the desired erlang version. Asdf will checkout erlang code and build this library on your machine. Problems come from here, I will explain on the issues section below.
Add elixir plugin to asdf.
Install the desired elixir version.

Notice that each Elixir release has multiple versions compiled with different major versions of Erlang/OTP. To maximize compatibility between Elixir and the Erlang runtime, choose a 1-otp-XY version that matches the major version of the runtime you installed in the previous step. For example:
```
asdf install elixir 1.11.2-otp-23
```
Set global (used for your whole computer) and local (used for specific directory) version.

Issues

When building erlang on your machine, you may encounter errors showing that cannot run some make commands. These issues are caused by the newest autoconf library version, a dependency of asdf. To solve this, please remove autoconf and then install it manually as the instruction in this link https://github.com/asdf-vm/asdf-erlang/issues/195#issuecomment-815999279
Cannot compile project after downgrading Elixir and Erlang. With this issue, please do some cleanups and then recompile the project:
```
rm -rf _build
mix deps.clean --all
mix clean
mix deps.get
mix compile
```
ElixirLS does not working. In my case, the newest ElixirLS version is 0.8.1, is not compatible with the installed Elixir version 1.10.3. So what I did is downgrade the ElixirLS to version 0.7.0:

Good luck!

Elixir intellisense stop working

Long Le — Sat, 11 Sep 2021 00:41:07 +0000

Recently, VSCode intellisense feature for elixir has stopped working on my Mac. Code autocomplete, go to definition, function description... are all failed. My colleagues encounter the same problem.
After researching, I found the root cause is ElixirLS has crashed from launching.

I tried to disable ElixirLS, close the editor, open the editor again and enable ElixirLS but no luck. I also tried to reinstall ElixirLS but nothing changes.
So I went to ElixirLS Github homepage, move to Troubleshooting region and I found the solution:

Remove .elixir_ls folder in project folder:
```
rm -rf .elixir_ls/ 
```
Close VSCode.
Open project in VSCode again, wait for ElixirLS run.
And voila!

Updated 2021-11-14:

If the above method does not work, you can try the final solution below:

Get your elixir path
```
which elixir
```
Edit the launch.sh file of elixir-ls extension (the file path can be seen in the log above), add the export PATH="elixir/path/here" before exec elixir command.

This way has an inconvenience that is every time you update the extension, you need to modify the launch.sh file again.

Implement token Authentication with Phoenix.Token

Dung Nguyen — Thu, 26 Aug 2021 13:42:44 +0000

In this post, you'll learn how to implement token based authentication using Phoenix.Token.

This is originally posted on The Orange+

In our previous projects, we use guardian library to implement JWT authentication. Guardian is a great library which provides lots of method and tool to work with authentication. But sometime we don't need them all. And recently, I found Phoenix.Token module shipped with phoenix framework that helps me to implement JWT alternative token authentication with few lines of code.

Let's do it.

1. Implement Token module

Here is the document of Phoenix.Token.

We just wrap sign and verify function from Phoenix.Token to create and check for valid token.

defmodule MyApp.Token do
  @signing_salt "octosell_api"
  # token for 2 week
  @token_age_secs 14 * 86_400

  @doc """
  Create token for given data
  """
  @spec sign(map()) :: binary()
  def sign(data) do
    Phoenix.Token.sign(MyAppWeb.Endpoint, @signing_salt, data)
  end


  @doc """
  Verify given token by:
  - Verify token signature
  - Verify expiration time
  """
  @spec verify(String.t()) :: {:ok, any()} | {:error, :unauthenticated}
  def verify(token) do
    case Phoenix.Token.verify(MyAppWeb.Endpoint, @signing_salt, token,
             max_age: @token_age_secs
           ) do
      {:ok, data} -> {:ok, data}
      _error -> {:error, :unauthenticated}
    end
  end
end

Here we wrap in Token module to simplify API. We pass MyAppWeb.Endpoint here to use secret key that config for endpoint. You can pass secret key from config as firt argument.

2. Generate token

defmodule MyAppWeb.SessionController do
  ...
  def new(conn, %{"email" => email, "password" => password}) do
    with {:ok, user} <- Account.authenticate_user(email, password),
         {:ok, token} <- MyApp.Token.sign(%{user_id: user.id}) do
      ...
      # return token to client
    else
      _ ->
        {:error, gettext("email or password is in correct")}
    end
  end
end

Here we create Phoenix token with a map %{user_id: user.id} and return to client.

3. Build Plug to verify token

Client sent token to server via header Authorization. We extract token and call Token.verify to check if token is valid and not expired.

defmodule MyApp.Plug.Authenticate do
  import Plug.Conn
  require Logger

  def init(opts) do
    opts
  end

  def call(conn, _opts) do
    with ["Bearer " <> token] <- get_req_header(conn, "authorization"),
         {:ok, data} <- MyApp.Token.verify(token) do
      conn
      |> assign(:current_user, MyApp.Account.get_user(data.user_id))
    else
      error ->
        conn
        |> put_status(:unauthorized)
        |> Phoenix.Controller.put_view(MyAppWeb.ErrorView)
        |> Phoenix.Controller.render(:"401")
        |> halt()
    end
  end
end

4. Add plug to router

defmodule MyAppWeb.Router do
  use MyAppWeb, :router

  pipeline :api do
    plug :accepts, ["json"]
  end

  pipeline :authenticated do
    plug MyAppWeb.Plug.Authenticate
  end

  scope "/api", MyAppWeb do
    pipe_through :api
    post "/auth/login", SessionController, :new
  end

  scope "/api", MyAppWeb do
    pipe_through [:api, :authenticated]
    delete "/auth/logout", SessionController, :delete
    ...
  end
end

We have done with it. Just a few line of code

Conclusion

Implement token authentication with Phoenix is so easy and you may not need Guardian for your application.
In this post I only implement simple version of token authentication. In real application, you should store token signature in database or redis and

In Authenticate plug check if the token exists in database.
When user logout, clear it from database/redis to make sure that token cannot be used to make request anymore.

Thanks for reading.

NOTES
If you want to known what is the different between JWT token and Phoenix.Token. Here is the answer from elixir forum

So, to answer the question: Phoenix.Token (with Plug Tokens) vs. JWT, several points I noticed:

Phoenix.Token doesn’t let you specify signing algorithms. JWT (for example using Joken 18) does.
Both encodes some form of payload into Base64, and the encoding can be read by clients (so you shouldn’t include sensitive information).
JWT allows you to encode arbitrary JSON objects as payload, Phoenix.Token uses Erlang terms serialization.

Product vs Software

Sophia Thuan — Sun, 22 Aug 2021 01:40:07 +0000

Đã bao giờ anh em thắc mắc: Product trong ngành công nghệ là gì? Nó khác gì với các “software” thông thường? Và ranh giới giữa một thứ được xem là “product” và một thứ “chỉ-được-xem-là-software” là gì ?

Nói theo ngôn ngữ marketing thì “Product is anything that can be offered to the market that satisfied a want or need“.

Với định nghĩa này thì product và software có vẻ không khác gì nhau. Nhưng thực tế nếu nhìn theo khía cạnh “quality of service“ thì sự khác biệt ở đây là cả… 1 bầu trời nghệ thuật.

Khác biệt
Các software mà anh em đang làm, những sản phẩm này thường “sống tốt” được ở những môi trường nào?

Software
Thường khi outsource hoặc làm phần mềm cho một khách hàng nào đó, end-user sẽ được gói gọn trong một tệp người khá rõ ràng.

Có nhiều yếu tố, nhưng mình chỉ muốn nói đến 2 yếu tố khác biệt rõ nhất giữa 1 software và 1 product đó là:

Số lượng người dùng
Và môi trường sử dụng

Tại một thời điểm nhất định, số lượng người dùng sẽ được giới hạn ở một con số nào đó. Thường khách hàng có thể có 20, 50, hoặc cả trăm người dùng. Con số có thể nhiều hơn, nhưng chắc chắn vẫn trong tầm ước lượng và kiểm soát của anh em.

Còn các yếu tố liên quan đến môi trường sử dụng của end-users có thể như:
Thiết bị họ dùng: nào là yêu cầu phần cứng, hệ điều hành, màn hình các kiểu…
Hoặc đơn giản như việc end-users phải được training đầy đủ, bài bản, hoành tráng thì mới có thể sử dụng được phần mềm của anh em.
Khi đã rõ 2 điều trên, anh em sẽ đỡ vả hơn rất rất nhiều trong việc maintain khi đưa phần mềm vào sử dụng thực tế. Mặc dù sự thật khá phũ là “làm xong” phần mềm đã là 1 câu chuyện đau đớn, đưa vào sử dụng còn đớn đau hơn gấp bội.

Đó là câu chuyện của việc cho ra đời một software thông thường. Còn với product thì sao?

Product
Hoàn toàn khác. Chắc chắn nó là một câu chuyện hoàn toàn khác.
Làm product, mọi thứ sẽ vô định hơn nhiều so với việc anh em làm một software có scope rõ ràng.

Số lượng end-users? Anh em sẽ phải luôn trong thế chuẩn bị cho các trường hợp khẩn cấp: lượng users sử dụng tăng cao, tăng đột biến..., bất kể lễ lộc hay weekend.

Còn nói về môi trường sử dụng thì là một câu chuyện dài, rất dài.
Đã là Product thì anh em sẽ phải quăng sản phẩm của mình vào scope đúng nghĩa của chữ “market”.
Tức sản phẩm của anh em phải sẵn sàng để sống tốt trong một thứ gọi là “the real world”. Nơi mọi thứ oái ăm, lạ đời nhất hoàn toàn đều có thể diễn ra.

Sự thật là anh em sẽ không tài nào lường trước được end-users họ sẽ làm gì với cái apps của mình.

Sẽ có một nghìn lẻ một trường hợp người dùng không thao tác theo luồng mình nghĩ đến từ đầu. Mà sẽ theo một cái luồng oái ăm nào đó. Mặc dù nghe vô lý nhưng lại rất thuyết phục.
…

Và sự thật là sản phẩm của anh em cần phải được quăng vào thế giới thực tế. Và PHẢI được dùng bởi người dùng thực tế ngoài kia, thì “khả năng hoàn thiện sản phẩm” mới tốt dần lên được.

Cùng đồng ý một điều là sẽ không có bất cứ sản phẩm công nghệ nào đạt được mức độ hoàn thiện ngay từ NHỮNG lần build đầu tiên cả. Cái gì cũng vậy, cần thời gian để cải thiện và nâng cấp dần dần.

Nhưng mấu chốt là anh em cần có FEEDBACK từ người dùng thì mới có thể làm được sự “cải thiện, và nâng cấp dần dần” đó. Và xuyên suốt quá trình lấy feedback từ người dùng, cái khó nhất vẫn luôn là: làm sao để họ chịu dùng sản phẩm của mình.

Nhưng…

Một thực trạng là anh em sẽ rất hay bị dí deadline trong môi trường các công ty outsource. Nào là khách hàng ép, dự án rush, nhu cầu gấp. Nói chung đụng đâu cũng thấy… nước sôi đổ tới háng hết. Dẫn tới timeline của anh em bị bóp nghẹt không thương tiếc.

Thử hỏi “làm xong” còn chưa kịp huống chi nói đến chuyện “làm đẹp”. Nó giống kiểu: anh em đang làm bài kiểm tra mà mắc đi “ấy” vậy.

Và cứ vậy, project này qua project khác, software này qua software khác, nó cứ như một nùi tả pí lù. Cứ “xong” theo kiểu bị dí, bị ép. Shit của ông này cứ chồng lên shit của ông khác, and so on, you know….

Ngoài ra, làm product là gắn liền với sự cải tiến liên tục.

Sẽ có chặn bắt đầu, nhưng thường không có chặn kết thúc như khi anh em làm các project outsource thông thường. 500 anh em sẽ phải liên tục theo dõi quá trình sử dụng của người dùng. Đưa ra những cải tiến kịp thời và phù hợp với thị trường hay chiến lược của sản phẩm.

Và thị trường hay nhu cầu của biz thì luôn thay đổi, thậm chí thay đổi từng giờ, từng ngày. Nên sẽ không bao giờ có chuyện “làm xong dự án” khi anh em làm product.

Nói gì nói anh em sẽ phải luôn gắn liền cuộc sống của mình với sản phẩm mình làm.

Nghĩa là, sản phẩm mà có shit, thì anh em vẫn là người hốt. Dù có lấp liếm được đến đâu đi chăng nữa, thì sau cùng vẫn chính là mình. Chính mình là người đi dọn những đống shit đó.

Cho nên ?

Do it one time, do it right
Vì không có thời gian nên anh em phải hết sức cố gắng làm chuẩn ngay từ đầu. Bất kể anh em có làm một product triệu đô, hay đơn thuần đang outsource một software thông thường đi chăng nữa.

Khái niệm “chuẩn” của mỗi người là khác nhau. Nhưng chắc chắn, quality của “chuẩn” nó sẽ HƠN NHIỀU so với “tàm tạm để test”, hay “vầy là ổn rồi”, hay “kệ m* nó đi vầy là được rồi!!!”

Nếu làm đúng ngay từ đầu, anh em sẽ đỡ tốn thời gian quay lại chỉnh sửa. Đó là nguyên lý.

Một function dù khó cỡ nào, nếu cố gắng phân tích đúng ngay từ đầu, thì nỗ lực sửa, fix bugs là rất ít.

Đặc biệt, công việc của người làm phân tích & thiết kế như BA/PO mà sai ngay từ đầu, thì rất dễ đẩy công sức của 500 anh em xuống biển. Đã không có thời gian, nay còn tự bóp mình. Kịch bản rất dễ đẩy các anh em vào con đường phạm pháp, quynh đệ tương tàn…

Làm việc có tâm, sâu sắc hơn một chút

Thêm một ý nữa là dù ít hay nhiều, hãy để tâm hơn một xíu ngay trong quá trình làm sản phẩm của mình. Dù cho anh em có đang outsource “theo đơn đặt hàng” cho một software nào đó.

Chúng ta, Biz Analyst, hay Dev, hay thậm chí cả QC khi design, build hay test một tính năng nào đó, HÃY LUÔN cố gắng đặt mình vào thế của người dùng cuối.

Dù biết thế giới này đã có rất nhiều yếu tố thọt vào đít anh em mỗi sớm thức dậy: deadline, sếp chửi, khách hàng dí, thằng chung team làm ẩu xém toang tám chục lần, vâng vâng và mây mây.

Đầu bếp nấu một món theo công thức có sẵn mà không quan tâm đến thực khách là ai, khẩu vị ra sao thì chắc chắn: món đó chỉ dừng ở mức “có thể ăn” của thực khách. Hoàn toàn không để lại ấn tượng hay feelings tốt đẹp gì về món đó cả. Thậm chí vài ngày sau là quên bà nó mất mình đã từng ăn món đó ở chỗ này.

Tạm kết
Đó là ranh giới vô cùng mong manh, nhưng cũng là cả một bầu trời khác biệt nếu nhìn theo góc độ quality of service.

Nói trắng ra là hoàn chỉnh sản phẩm hơn mỗi ngày. Để sản phẩm ngày càng tiệm cận đến mức độ hoàn thiện cao nhất mà nó có thể.

Nói vậy nhưng thực tế sẽ luôn gặp trở ngại để làm được như vậy. Cái THÚ ở đây là nằm ở khả năng luồn lách vượt trở ngại của anh em, để hoàn thiện sản phẩm được đến mức nào mà thôi.

Chúc anh em may mắn, các anh/em hãy đi fix bugs tiếp đi nhoa, baiiii.

Concurrent Programming với Elixir

Toan Ha — Sat, 21 Aug 2021 07:10:31 +0000

Mục đích bài viết này để

Giới thiệu về phương pháp lập trình bất đồng bộ với cách tiếp cận khác những ngôn ngữ như Java hoặc C#.
Những bước đầu tiên để viết 1 chương trình chạy bất đồng bộ bằng Elixir
Hi vọng sẽ lôi kéo được thêm người học Elixir :)

1. Concurrent Programming

Concurrent Programming hiểu đơn giản là việc lập trình cho phần mềm có thể chia nhỏ tác vụ và chạy đồng thời, độc lập với nhau. Elixir là ngôn ngữ lập trình được viết dựa trên nền tảng ngôn ngữ erlang - ngôn ngữ giải quyết bài toán concurrent trên rất tốt.

Nếu trong Java hay C# việc lập trình bất đồng bộ bạn sẽ sữ dụng những phương pháp như Locking, Thread pool, mutex hay là semaphore... thì ở Elixir sẽ cài đặt trên mô hình Actor model (1).

Actor là một đơn vị chính của mô hình Actor model và đảm nhận mọi thao tác tính toán trong mô hình này. Các đặc điểm chính của actors bao gồm:

message passing - các actor trao đổi với nhau bằng cách gửi message vào mailbox của nhau. Bạn muốn bảo một actor làm gì cho bạn: gửi message cho nó. Bạn muốn giết một actor: gửi message cho nó. Bạn muốn truy cập thông tin một actor: gửi message cho nó rồi check mailbox.
never share memory - mỗi actor có một state riêng mà không có actor nào có thể truy cập hay thay đổi được.
there are many actors - Actor là thứ sống theo bầy đàn. Trong mô hình này, tất cả đều là actor hoặc không có một actor nào cả. Đồng thời actor được định danh (giống như bạn được cha mẹ bạn cấp cho cái tên), tui sẽ nói rõ hơn về cái này trong phần tiếp theo.
asynchronous - mọi message đều là bất đồng bộ, tức là lúc bạn bấm gửi và lúc nào nó tới là hai chuyện khác nhau.

Khi nhận được một message, actor sẽ phải băn khoăn với 3 lựa chọn:

Xử lý thông tin và update state của nó.
Tạo thêm các actor khác.
Gửi message cho một actor khác.

Đoạn này là copy trên Blog Quần Cam vì ảnh giải thích khá dễ hiểu về mô hình này, đọc thêm tại đây

Có 1 tính chất trong elixir đó chính là Immutability mình xin tạm dịch là tính bất biến. Hãy cùng xem đoạn code dưới đây:

array = [1, 2, 3]
square(array)
print(array)

Giả sử hàm square sẽ bình phương giá trị từng phần tử trong mảng array. Bạn mong đợi kết quả trả về là [1, 4, 9]. Nhưng trong elixir kết quả sẽ trả về là [1, 2, 3] trừ khi bạn gán lại kết quả cho biến array như code dưới đây

array = [ 1, 2, 3 ]
array = square(array)
print(array)

Tính chất này giúp cho việc lập trình bất đồng bộ đơn giản hơn rất nhiều vì bạn không cần phải lo giá trị của 1 biến bị thay đổi bởi 1 process khác. Đây là 1 tính chất khá thú vị ở Elixir. Nhưng cái gì cũng sẽ có 2 mặt tốt và chưa tốt.
Bạn có thể tìm đọc thêm ở (2).

2. Làm quen với Concurrent Programming trong elixir

Nói 1 chút về process trong elixir. Process trong elixir khác với process chạy trên máy tính của bạn, nó chạy bên trong máy ảo erlang VM được quản lý trong ứng dụng của bạn. Trung bình 1 node trên chạy trên máy ảo erlang có thể tạo được 134 triệu processes con. Con số khá ấn tượng nhỉ :)

Việc khởi tạo 1 process trong elixir cũng rất đơn giản. Cùng xem ví dụ dưới đây:

# Đoạn code này định nghĩa 1 module trong elixir và code 1 hàm là greet in ra màn
# hình là "Hello"
defmodule SpawnBasic do
  def greet do
    IO.puts "Hello"
  end
end

# Đây là cách gọi hàm thông thường
SpawnBasic.greet
Hello
:ok

# Còn đây là cách để chạy hàm trên trong 1 process
spawn(SpawnBasic, :greet, [])
Hello
#PID<0.42.0>

Kết quả trả về của hàm spawn là 1 địa chỉ tới process vừa khởi tạo. Tiếp theo chúng ta sẽ đến phần giao tiếp giữa các process với nhau thế nào.

Trong elixir có 2 hàm là send dùng để gửi message tới 1 process và hàm receive để nhận 1 message từ 1 process khác gọi sang. Thay đổi 1 chút đoạn code trên.

defmodule Spawn do
  def greet do
    # Hàm này sẽ giúp nhận đối số từ bên ngoài
    receive do
      # sender là process gọi tới hàm này và msg là tin nhắn được gửi sang
      {sender, msg} ->
        # Dùng hàm send để gửi lại cho sender kết quả (*)
        send sender, { :ok, "Hello, #{msg}" }
    end
  end
end

# Khởi tạo process
pid = spawn(Spawn, :greet, [])
# Gửi tin nhắn tới process đó
send pid, {self, "World!"}
# Lắng nghe kết quả trả về
receive do
  # Chổ này sẽ match với giá trị trả về của hàm greet bên trên (*)
  {:ok, message} ->
    IO.puts message
end

Output:
> Hello, World!

Đoạn code trên nếu ta tiếp tục gọi thêm 1 message nữa

...
send pid, {self, "Ahihi!"}
receive do
  {:ok, message} ->
    IO.puts message
end

Output:
> Hello, World!
...stop...

Chương trình bị dừng thay vì tiếp tục trả về message là Hello, Ahihi!. Do sau khi hàm greet nhận được message thì đã gọi gửi trở lại cho main process và exit khỏi chương trình.

Giải thích chỗ này 1 chút đó là function trong elixir sẽ trả về kết quả ở dòng cuối cùng của thân hàm. Trong đoạn code trên hàm greet sẽ trả về pid là kết quả trả về của lời gọi hàm send

Vậy làm sao để nhận được kết quả mong muốn là Hello, Ahihi! ở lần send message thứ 2?

Chúng ta sẽ thay đổi hàm greet để trả về lời gọi hàm chính nó để khi send tiếp tục lắng nghe tin nhắn từ main process

def greet do
  receive do
    {sender, msg} ->
      send sender, { :ok, "Hello, #{msg}" }
      greet
  end
end

Output:
> Hello, World!
> Hello, Ahihi!

Đoạn code này trong giống đệ quy phải không?

Đúng rồi, đây là đệ quy trong elixir

Nếu trong những ngôn ngữ khác như Java thì khi gọi đệ quy tức là bạn push 1 frame vào stack và nếu bị gọi với số lượng lớn nó sẽ bị out of memory. Vấn đề này được giải quyết bằng kĩ thuật tail-call optimization có thể hiểu là nếu như hàm trả về chính nó thì chương trình chỉ đơn giản là nhảy về điểm bắt đầu của chương trình.

Đây là 1 bài toán tìm số factorial thứ n được viết bằng đệ quy

def factorial(0), do: 1
def factorial(n), do: n * factorial(n-1)

Với n = 3 chương trình sẽ chạy như sau
3 * factorial(3-1)
3 * 2 * factorial(2-1)
3 * 2 * 1 * factorial(1-1)
3 * 2 * 1 * 1
6

Nhưng đây không phải là tail-call optimization bởi vì kết quả trả về của hàm thứ 2 không trả về chính nó mà trả về kết quả của 1 phép nhân. Thay đổi 1 chút như bên dưới

def factorial(n), do: _fact(n, 1)
defp _fact(0, acc), do: acc
defp _fact(n, acc), do: _fact(n-1, acc*n)

Với n = 3
_fact(3-2, 1*3) => _fact(2, 3)
_fact(2-1, 3*2) => _fact(1, 6)
_fact(1-1, 6*1) => _fact(0, 6)
6

Chương trình này sẽ dùng biến acc để tracking lại giá trị của số trước nó, và chương trình sẽ chạy lùi từ n về 0. Nhưng như đã nói, mọi thứ đều có 2 mặt tốt và chưa tốt. Để hiểu thêm bạn có thể tham khảo ở (3)

Nhưng nếu mình muốn mọi thứ đồng bộ nhưng vẫn chạy thành nhiều process có được không?

Được, cùng xem ví dụ dưới đây

defmodule Demo1 do
  def say do
    receive do
      n ->
        IO.inspect(n)
    end
  end
end

nums = 1..10

Enum.each(nums, fn i ->
  pid = spawn(Demo1, :say, [])
  send(pid, i)
end)

defmodule Demo2 do
  def say(pid) do
    receive do
      n ->
        send(pid, n)
    end
  end
end

Enum.each(nums, fn i ->
  pid = spawn(Demo2, :say, [self])
  send(pid, i)

  receive do
    n ->
      IO.inspect(n)
  end
end)

Output:
# Demo1 cách này sẽ giúp bạn khởi tạo và chạy các process mà không quan tâm giá trị trả về có đúng thứ tự không
1
3
2
7
4
10
8
6
5
9

# Demo2 sẽ đảm bảo kết quả trả về đúng thứ tự
1
2
3
4
5
6
7
8
9
10

Trong elixir có 1 hàm giúp ta link được 2 process với nhau đó là hàm spawn_link

defmodule Demo do
  import :timer, only: [sleep: 1]

  def die_soon do
    sleep(500)
    exit(:dead)
  end

  def run do
    # Process.flag(:trap_exit, true)
    spawn_link(Demo, :die_soon, [])

    receive do
      msg ->
        IO.puts("Message: #{inspect(msg)}")
    after
      1000 ->
        IO.puts("I'm still alive")
    end
  end
end

Demo.run()

Output:
** (EXIT from #PID<0.73.0>) :dead

Chương trình trên bị dừng khi process con bị chết, nó sẽ ảnh hưởng tới thằng cha làm chết theo. Để process cha không chết ta bỏ comment chỗ Process.flag(:trap_exit, true) lúc này chương trình không bị dừng mà output ra là

Message: {:EXIT, #PID<0.78.0>, :dead}

3. Kết

Hi vọng các bạn có một góc nhìn khác, một hướng tiếp cận khác về lập trình đa luồng và quan trọng nhất là sẽ có bạn tìm hiểu thử về Elixir sau khi đọc xong bài viết này. Nếu bạn có bất cứ thắc mắc hay câu hỏi nào thì vui lòng comment vào bên dưới bài viết. Mình sẽ cố gắng trả lời các câu hỏi nếu trong phạm vi hiểu biết :)

Đọc thêm:

Ref: Elixir book

Phân biệt các từ khóa use, alias, require và import

Toan Ha — Sat, 21 Aug 2021 07:09:53 +0000

Khi mới tiếp cận với Elixir các bạn có thể sẽ phân vân điểm khác nhau giữa các từ khoá trên. Bài viết này so sánh các từ khoá đó thông qua cách sử dụng

1. import

Hiểu đơn giản nó sẽ bê toàn bộ functions và macros của module B vô module A để sử dụng. Mình có thể gọi tắt 1 function trong B mà không cần bắt đầu bằng tên module.

defmodule A do
  def say_world() do
    IO.puts("world")
  end

  defmacro if_unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

defmodule B do
  import A

  def say_hello do
    IO.puts("Hello ")
    if_unless false do
      say_world()
    end
  end
end

Có thể sử dụng thêm 2 từ khóa only nếu chỉ muốn lấy 1 số hàm, marco hoặc từ khóa except nếu muốn loại từ hàm hay macro nào đó

import List, only: [flatten: 1]
import String, except: [split: 2]

Import có thể sử dụng bên trong function và có scope chỉ ở trong function đó.

defmodule Math do
    def some_function do
        # 1) Disable "if/2" from Kernel
        import Kernel, except: [if: 2]

        # 2) Require the new "if/2" macro from MyMacros
        import MyMacros

        # 3) Use the new macro
        if do_something, it_works
    end
end

Lưu ý: Các hàm bắt đầu bằng _ sẽ không được import. Ví dụ: (__build__, ...)

2. require

Khi muốn sử dụng marco của 1 module nào đó, bắt buộc phải require module đó trước khi gọi marco

defmodule A do
  def say_world() do
    IO.puts("world")
  end

  defmacro if_unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

defmodule B do
  require A

  def say_hello do
    IO.puts("Hello ")

    A.if_unless false do
      A.say_world()
    end
  end
end

3. alias

Dùng để setup 1 alias name cho 1 module. Mặc định thì alias sẽ lấy phần cuối cùng trong tên module làm tên alias.

defmodule A do
    alias Foo.Bar.Baz

    def funcA do
        Baz.some_func()
    end
end

Có thể sử dụng key as để định nghĩa 1 tên khác.

defmodule A do
    alias Foo.Bar.Baz, as: FBar

    def funcA do
        FBar.some_func()
    end
end

Mình có thể định nghĩa nhiều alias có module tương tự nhau trong cùng 1 hàng

alias Foo.Bar
alias Foo.Baz
alias Foo.Biz

> alias Foo.{Bar, Baz, Biz}

Chú ý: import/2, require/2 và alias/2 có thế định nghĩa trong từng function khác nhau không nhất thiết phải để ngay sau defmodule và nó không ảnh hưởng scope lẫn nhau.

4. use

Thường xài kiểu như abstract, Khi module B use module A, nó sẽ invoke marco __using__ trong module A

defmodule A do
  defmacro __using__(opts) do
    quote do
      IO.puts("Hello ")
    end
  end
end

defmodule B do
  use A, key1: "abc"

  def say_hello do
    IO.puts("World")
  end
end

đoạn code trên tương đương với

defmodule B do
  B.__using__([key1: "abc"])

  def say_hello do
    IO.puts("World")
  end
end

use thường được dùng khi muốn định nghĩa 1 behavior cho 1 module. Ví dụ trong Phoenix Framework. Controller được định nghĩa

defmodule ApiWeb do
...
    def controller do
        quote do
            use Phoenix.Controller, namespace: ApiWeb
            import Plug.Conn
            import ApiWeb.Router.Helpers
            import ApiWeb.Gettext
            require Logger
        end
    end
...
end

defmodule ApiWeb.PageController do
    use ApiWeb, :controller
    ...
end

Lưu ý: Không nên định nghĩa hàm ở trong __using__/1

Kết

Các bạn có thể tham gia vào channel #elixir ở cộng đồng Ruby Việt Nam để thảo luận thêm về các vấn đề khi lập trình với elixir :)

Encrypt your database with Ecto custom type

Dung Nguyen — Fri, 20 Aug 2021 12:10:14 +0000

If your data is encrypted, even if it's leaked, no one know what is the data. That's great.

In this post, I'm going to show you how to encrypt data with Ecto. Ecto allows developer to define their own types. And we will define a type called EncryptedText which encrypts data before persiting to database and decrypts data after loading.

1. Define encrypt/decrypt methods

This is a simple version of crypto module:

defmodule Crypto do
  @block_size 16

  def generate_secret do
    :crypto.strong_rand_bytes(@block_size)
    |> Base.encode64()
  end

  def encrypt(plaintext, secret_key) do
    with {:ok, secret_key} <- decode_key(secret_key) do
      iv = :crypto.strong_rand_bytes(@block_size)
      plaintext = pad(plaintext, @block_size)
      ciphertext = :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, plaintext, true)

      {:ok, Base.encode64(iv <> ciphertext)}
    end
  end

  def decrypt(ciphertext, secret_key) do
    with {:ok, secret_key} <- decode_key(secret_key),
         {:ok, <<iv::binary-@block_size, ciphertext::binary>>} <- Base.decode64(ciphertext) do
      plaintext =
        :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, ciphertext, false)
        |> unpad

      {:ok, plaintext}
    else
      {:error, _} = err -> err
      _ -> {:error, "Bad encrypted data"}
    end
  end

  defp pad(data, block_size) do
    to_add = block_size - rem(byte_size(data), block_size)
    data <> :binary.copy(<<to_add>>, to_add)
  end

  defp unpad(data) do
    to_remove = :binary.last(data)
    :binary.part(data, 0, byte_size(data) - to_remove)
  end
end

Let go through the code

  def generate_secret do
    :crypto.strong_rand_bytes(@block_size)
    |> Base.encode64()
  end

This function generate a 16 bytes secret key and encode base 64 string so you can add it to config.

encrypt/2 function

 def encrypt(plaintext, secret_key) do
    # check the key size
    with {:ok, secret_key} <- decode_key(secret_key) do

      # random initial vector
      iv = :crypto.strong_rand_bytes(@block_size)
      # if length of text is not multiple of @block_size
      # we add more data until it meets condition
      plaintext = pad(plaintext, @block_size)
      # encrypt here
      ciphertext = :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, plaintext, true)

      {:ok, Base.encode64(iv <> ciphertext)}
    end
  end

This is the most important line

ciphertext = :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, plaintext, true)

iv is initial vector. AES-128 algorithms encrypts data by block of 16 bytes, so we need initial vector to make sure that the output of blocks with same data are different from each other.
The last parameter is set to true to encrypt, set to false to decrypt data

And then we encode output to base 64 string. Here we concatenate iv and ciphertext so that we can extract iv to use for decrypting

{:ok, Base.encode64(iv <> ciphertext)}

decrypt/2 function

def decrypt(ciphertext, secret_key) do
    # check the key
    with {:ok, secret_key} <- decode_key(secret_key),
         {:ok, <<iv::binary-@block_size, ciphertext::binary>>} <- Base.decode64(ciphertext) do
      plaintext =
        :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, ciphertext, false)
        |> unpad

      {:ok, plaintext}
    else
      {:error, _} = err -> err
      _ -> {:error, "Bad encrypted data"}
    end
  end

We extract iv and encrypted data from input

{:ok, <<iv::binary-@block_size, ciphertext::binary>>} <- Base.decode64(ciphertext)

We use pattern matching to extract first 16 byte and assign to iv and assign remaining data to ciphertext. Then decrypting data

plaintext =
    :crypto.crypto_one_time(:aes_128_cbc, secret_key, iv, ciphertext, false)
    |> unpad

This line is similar to the line which encrypts data, the difference is here we replace plaintext by ciphertext and last parameter is set to false. After data is decrypted, we need to remove padding to get the original data.

2. Build `EncryptedText` type

I define a type to store binary data, you can define a EncryptedMap to store map data. The most important function are dump and load where we encrypt before persisting and decrypt after loading.

defmodule EncryptedText do
  use Ecto.Type

  # we store data as string
  def type, do: :string

  def cast(value) when is_binary(value) do
    {:ok, value}
  end
  def cast(_), do: :error

  def dump(nil), do: nil
  # encrypt data before persist to database
  def dump(data) when is_binary(data) do
    with {:ok, secret_key} <- Application.fetch_env(:myapp, :ecto_secret_key),
         {:ok, data} <- Crypto.encrypt(data, secret_key) do
      {:ok, data}
    else
      _ -> :error
    end
  end

  def dump(_), do: :error

  def load(nil), do: nil
  # decrypt data after loaded from database
  def load(data) when is_binary(data) do
    secret_key = Application.fetch_env!(:myapp, :ecto_secret_key)
    case Crypto.decrypt(data, secret_key) do
      {:error, _} -> :error
      ok -> ok
    end
  end

  def load(_), do: :error

  def embed_as(_), do: :dump
end

3. Use it in your schema

You must add secret key to your app config first.

config :myapp, :ecto_secret_key, "your key using Crypto.generate_secret"

Add to schema

schema "users" do
    field :name, :string
    ...
    field :secret, EncryptedText
    ...
end

Your data are safe now.

4. Conclusion

With Crypto you can implement encrypted field for any type of data you want.

There is an issue when you want to change your secret key, you have to load your data row by row, decrypt and then encrypt with new key and update to database.

I found this article which explains very well about crypto if you are interested https://www.thegreatcodeadventure.com/elixir-encryption-with-erlang-crypto/
Although she uses old crypto API so it will throw some warnings.

I implemented encrypted type for text and map for my company project here if you want to use it:

Github

Thanks for reading.

How to validate request params in Phoenix

Dung Nguyen — Sat, 14 Aug 2021 05:06:03 +0000

In web developments, server receives lots of request data from client side. And when working with request params from client, my first rule is:

Don't believe the client

Imagine that you provide API to list all post using the filter from client, and user may add user_id which point to other user, and you don't remove that unexpected field from request params. If you don't handle your logic carefully, you may accidentally leak data.

So every request should be cleaned from unexpected params, casted to the proper data type, and validated before passing to business layer.

You can achieve this by:

Using Ecto

If you are building a web server using Phoenix, I guess Ecto is already in your dependencies. Just use it.

Thank to Ecto schemaless, you can build changeset from a dynamic schema:

defmodule MyApp.PostController do
    ...
    defp index_params(params) do
        default = %{
      status: nil,
      q: nil,
      is_published: true
    }

    types = %{
      status: :string,
      q: :string,
      is_published: :boolean
    }

    changeset =
      {default, types}
      |> Ecto.Changeset.cast(params, Map.keys(types))

    if changeset.valid? do
        {:ok, Ecto.Changeset.apply_changes(changeset)}
    else
        {:error, changeset}
    end
    end

    def index(conn, params) do
        with {:ok, valid_params} <- index_params(params) do
            # do your logic
        end
    end
    ...
end

With Ecto you can do validation on your params as you do with your schema changeset.

This way is simple and most of you are familiar with it. But you have to write much code and cannot cast and validate nested params.

Use library `Tarams`

This library provide a simple way to define schema. Let's rewrite example above using tarams.

First add this to your dependency list:

{:tarams, "~> 1.0.0"}

defmodule MyApp.PostController do
    ...
    @index_params %{
        status: :string,
        q: :string
        is_published: [type: :boolean, default: true],
        page: [type: :integer, number: [min: 1]],
        size: [type: :integer, number: [min: 10, max: 100]]
    }
    def index(conn, params) do
        with {:ok, valid_params} <- Tarams.cast(params, @index_params) do
            # do your logic
        end
    end
    ...
end

And it support nested params too

defmodule MyApp.PostController do
    ...
    @create_params %{
        title: [type: :string, required: true],
        content: [type: :string, required: true],
        tags: [type: {:array, :string}],
        published_at: :naive_datetime,
        meta: %{
            tile: :string,
            description: :string,
            image: :string
        }
    }
    def create(conn, params) do
        with {:ok, valid_params} <- Tarams.cast(params, @create_params) do
            MyApp.Content.create_post(valid_params)
        end
    end
    ...
end

Conclusion

All request params should be casted and validated at controller. Then you only work with data that you know what it is, and you don't have to worry about unexpected parameters.

Thanks for reading, hope it can helps.

DEV Community: OnPoint Vietnam

[TIL] Reusable LiveView.JS commands with JS.exec

1. Duplicated code

2. Writing a function

3. Reuse code with JS.exec

How to download large file in Elixir

What you will learn

1. Build the stream

2. Open connection

3. Stream chunks

4. Close connection

5. Save to the file

6. Stream by line

References

Build your own date time parser in Elixir

1. Define format string.

2. Build regex pattern from format string

3. Capture all required parts

4. Build datetime struct from captured parts

4.1 Cast and validate data

4.2 Combine those all parts

Conclusion

Installing Erlang & Elixir on M1 Macs

Install old Erlang and Elixir version with asdf

Issues

Elixir intellisense stop working

Updated 2021-11-14:

Implement token Authentication with Phoenix.Token

1. Implement Token module

2. Generate token

3. Build Plug to verify token

4. Add plug to router

Conclusion

Product vs Software

Concurrent Programming với Elixir

1. Concurrent Programming

2. Làm quen với Concurrent Programming trong elixir

3. Kết

Phân biệt các từ khóa use, alias, require và import

1. import

2. require

3. alias

4. use

Kết

Encrypt your database with Ecto custom type

1. Define encrypt/decrypt methods

2. Build EncryptedText type

3. Use it in your schema

4. Conclusion

How to validate request params in Phoenix

Using Ecto

Use library Tarams

Conclusion

3. Reuse code with `JS.exec`

2. Build `EncryptedText` type

Use library `Tarams`