DEV Community: Kelvin Mai

How To Integrate HoneySQL with PostgreSQL

Kelvin Mai — Thu, 12 Nov 2020 19:08:16 +0000

In returning to clojure, there was one library that I wanted to check out and that one is honeysql. HoneySQL is a library where you can create a clojure map and use the sql/format function to turn that map into a raw sql query.

(require '[honeysql.core :as sql]
         '[honeysql.helpers :refer :all :as helpers])

(def sqlmap {:select [:a :b :c]
             :from   [:foo]
             :where  [:= :f.a "baz"]})

(sql/format sqlmap)
;; => ["SELECT a, b, c FROM foo WHERE f.a = ?" "baz"]

The above example is one that shows off the capabilities of the library, but below we have the classic "get everything" query for simplicity's sake.

(def sqlmap {:select [:*]
             :from   [:bar]})

(sql/format sqlmap)
;; => ["SELECT * FROM bar"]

But there is one small problem, the library is very useful in creating raw query strings, but I couldn't find an example of actually executing these queries, and that is what I want to accomplish with this post. For this post we'll be using the Clojure CLI rather than lieningen, so I have included the minimum configuration of a deps.edn file below as well as a nrepl alias.

{:paths ["src"]
 :deps {org.clojure/clojure {:mvn/version "1.10.1"}
        org.postgresql/postgresql {:mvn/version "42.2.2"}
        seancorfield/next.jdbc {:mvn/version "1.1.613"}
        honeysql/honeysql {:mvn/version "1.0.444"}}
 :aliases {:nrepl {:extra-deps {nrepl/nrepl {:mvn/version "0.8.0"}
                                cider/cider-nrepl {:mvn/version "0.25.2"}}
                   :main-opts ["-m" "nrepl.cmdline" "--middleware" "[cider.nrepl/cider-middleware]"]}}

Some of these versions may have been updated, so make sure to check clojars, and for this example I will be using postgres as the database of choice if you are instead interested in a different data source, relevant links to the drivers are available on the clojure jdbc library readme. Speaking of which, even though we'll be using next.jdbc, the initial configuration def will be the same as shown below.

(ns example.db
  (:require [next.jdbc :as jdbc]))

(def db-config
  {:dbtype "postgresql"
   :dbname "example_db"
   :host "localhost"
   :user "postgres"
   :password "postgres"})

(def db (jdbc/get-datasource db-config))

I'm unsure what the difference between the original jdbc and next.jdbc is, but figured it would be a good idea to use the latest and greatest connection library and skip whatever headaches were present that prompted the creation of this new library. Here you can see that connection configuration being used by jdbc/get-datasource and the persisted connection is held in the db var. And now all we need to do now is to execute queries which we can do by calling jdbc/execute!. It's important to note that the first argument is the database connection which we've defined above.

(jdbc/execute! db ["CREATE TABLE thing (
                     id SERIAL,
                     title TEXT,
                     description TEXT)"])
;; => [#:next.jdbc{:update-count 0}]

(jdbc/execute! db ["SELECT * FROM thing"])
;; => []

And lastly instead of writing raw sql, we come full circle and can now use the honeysql library to pass in formatted sql maps. So simply replace the vector of sql queries with some honeysql operations. So if we were to run the following in the repl, we'll get some desired side effects. (The libraries are aliased as above from the require statements.)

(jdbc/execute! db (sql/format
                      {:select [:*]
                       :from [:thing]}))
;; => []

(jdbc/execute! db (sql/format
                      {:insert-into :thing
                       :columns [:text :description]
                       :values [["blog" "written articles"]
                                ["article" "blog post"]]}))
;; => [#:next.jdbc{:update-count 2}]
;; => [#:thing{:id 1, :title "blog", :description "written articles"}

(jdbc/execute! db (sql/format
                      {:select [:*]
                       :from [:thing]}))
;; => [#:thing{:id 2, :title "article", :description "blog post"}]

And that's all there is to it, I hope some have found this post useful.

Resources

Follow and support me

Build a Port Scanner in Golang

Kelvin Mai — Tue, 29 Sep 2020 16:01:35 +0000

In this video we create the freeCodeCamp port scanner project but instead of python, this application is written in golang.

Resources

Follow and support me

How To Build a Full Stack Clojure Project

Kelvin Mai — Mon, 03 Aug 2020 17:44:27 +0000

This is a video series that covers building a simple full stack CRUD application with clojure and clojurescript.

What you will learn

The main focus here is the language of clojure itself, and the libraries used isn't as important. There is a small assumption that you are already a javascript/react developer and so some technologies have been chosen should be familiar, like the usage of VS Code instead of emacs. This is also the reason why helix was chosen instead of something more popular like reagent, because if you already know modern React, I didn't want that knowledge to be thrown away. If you don't know modern react however, it shouldn't be difficult to follow along.

Reitit Ring Set Up

Manage dependencies with deps.edn
Set up a ring server with http-kit and reitit
Add middlewares and test routes

Database Configuration

Use hugsql to connect to a postgresql database
Write SQL to generate CRUD functions

API endpoints

Create api routes and endpoints for each of the CRUD operations

Front End Preparation

Set up shadow-cljs for front end dev server and dependencies
Use Helix to add React to our front end
Add Taliwind CSS for styling and theming
Connect to the backend api we've built

React Components

Create react components by using the helix library

State Management

Set up a redux style state management system using react context
Introduction to clojure multimethods

Final Integration

Integrating our state management with api requests
A little bit of styling with tailwind css

Follow and support me

Understanding Clojure Multimethods

Kelvin Mai — Mon, 20 Jul 2020 21:31:47 +0000

It took me quite a while to wrap my head around clojure's multimethods, which is clojure's version of pattern matching and polymorphism. Pattern matching is a pretty core part of how functional programming languages to combat the ambiguaty of null. The big draw to it in typed languages like scala and ocaml is to exhaust all possibilites, however clojure is a dynamically typed language so there is a different interest here. We're interested in the branching paths, kinda like an expanded if statement, to call a different function depending on the condition. Javascript and other C-like languages can do a pretty good impression of this with the switch statement.

const switchFn = (condition) => {
  switch (condition) {
    case "true":
      console.log(true);
      break;
    case "false":
      console.log(false);
      break;
    default:
      console.log("maybe?");
      break;
  }
};

Here is the clojure equivalent of a switch case, using clojure keywords (used by the ':' syntax) instead of strings as the conditions. And it may not be the best example for boolean cases, as you would opt for a switch when you have more than 2 possibilities. But this is the

(defn switch-fn [condition]
  (case condition
    :true (prn true)
    :false (prn false)
    :default (prn "maybe?")))

But the downside of the case function is that to update the functionality you would have to edit the function altogether. It may not seem like that big of a deal until polymorphism is taken into account. Say for example you want to add an additional case to a third party library, which may be almost impossible. This is an extreme case, but it does illustrate the limitations of a switch case.

Multimethods

And that's where clojure's multimethods come in. Using the defmulti and defmethod macros we can define both the switch and cases separately.

(defmulti factorial identity)

(defmethod factorial 0 [_]  1)
(defmethod factorial :default [num]
    (* num (factorial (dec num))))

(factorial 0) ; => 1
(factorial 1) ; => 1
(factorial 3) ; => 6
(factorial 7) ; => 5040

This is an example of implementing a factorial function with multimethods instead of the more typical recursive alternative. The defmulti macro's form structure first takes in the name of the multimethod, and subsequently each defmethod's first param must be the name of the same as the one in defmulti so that clojure knows which multimethod it belongs to. The second argument of defmulti defines the function on how to determine wich method to use, here it's provided the identity method so whatever number is provided will be the case. In the methods, the second is the cases and uses a :default as the default case and the last param is the return value. The list param is what confused me, it will match the same input as the defmulti so it will always include the cases, in this factorial example it's not too complex as the number is also the condition. But if you want a React/Redux style action dispatch system it will end up looking like this instead.

(defmulti app-reducer
  (fn [state action] (first action)))

(defmethod app-reducer
  :set-list [state [action-type payload]]
  (or payload state))

(defmethod app-reducer
  :add-to-list [state [action-type payload]]
  (conj state payload))

;; calling the actions here
(app-reducer state [:set-list [1 2 3]])
(app-reducer state [:add-to-list 4])

With the redux style reducer you will always have 2 arguments, the state and action, but the action is then divided into it's action type and payload. So to maintain arity (number of arguments) the action here is embedded in a list of it's own, being destructured in each of the defmethods. In the defmulti the function here returns just the action type to determine which condition to use, which is why it returns the first in the action list. But in the methods return value we are only interested in the payload, so we ignore the action type as it has already been used to determine which method.

Follow and support me

Introduction to Clojure Ring

Kelvin Mai — Fri, 10 Jul 2020 14:43:23 +0000

This is an introduction to clojure ring. Ring is a low level library that makes it possible to build web servers, it's important to understand the internals of this library as most, if not all other web frameworks in clojure is built on top of Ring.

Included in video

Project setup with deps.edn
VS Code Calva editor integration
Setting up a ring server
Explanation of middleware usage with ring

Resource Links

Ring

Follow and support me

How to Set Up Shadow CLJS

Kelvin Mai — Mon, 06 Jul 2020 14:34:21 +0000

This is a simple walkthrough of how to set up a shadow cljs project

Included in video

Configuring a shadow-cljs edn file
Adding clojurescript support in the chrome console
Adding CLJS/JS dependencies and interoping with existing Javascript libraries

The completed shadow-cljs.edn file will look like this

{:source-paths ["src/cljs"]
 :nrepl {:port 9000}
 :dependencies [[cider/cider-nrepl "0.21.0"]
                [binaryage/devtools "1.0.2"]
                [lilactown/helix "0.0.13"]]
 :builds {:app {:target :browser
                :output-dir "resources/public/js"
                :modules {:main {:init-fn app.core/init}}
                :devtools {:preloads [devtools.preload]
                           :http-root "resources/public"
                           :http-port 3000}}}}

Resource Links

Shadow CLJS
Shadow CLJS Docs
Lokeh/helix

Follow and support me

A Dinosaur Rest API with Dactyl and denoDB

Kelvin Mai — Mon, 29 Jun 2020 15:51:28 +0000

In this video, I try out deno by creating a simple REST API with database crud operations using the Dactyl web framework as well as the denodb library. Dactyl aims to be the NestJS of deno and built on top of Oak.

Included in video

Creating a deno project from scratch
Adding a custom tsconfig for deno
Dependency management with file architecture
Connecting to a postgres database with denodb
Serving api endpoints with dactyl

Resource Links

Follow and support me

Create the Frontend Mentor Countries app in Angular

Kelvin Mai — Mon, 22 Jun 2020 15:30:47 +0000

In this video series, I took the frontend mentor challenge to do the countries REST api application with Angular.

Included in video

Setting up an Angular 9
Generating components and services with the Angular CLI
RxJS Observable logic for global theme state
Lots of SCSS with some special Angular host-context
Creating a component with 2 way binding

Resource Links

Follow and support me

Use Docker and Docker Compose for Local Databases

Kelvin Mai — Mon, 15 Jun 2020 16:30:21 +0000

Just a quick introduction video on how to use docker and docker-compose for developing with local databases like postgres or mongodb

Included in Video

How to use the docker cli
Pull docker images
Start docker container with image and options
Executing commands inside docker container
Writing a docker compose file
Using docker compose for multiple containers
Multiple container interactions

Resource Links

How to create a Weather App in Reason and React

Kelvin Mai — Fri, 12 Jun 2020 16:30:31 +0000

Topics covered in this video includes:

Reason interop with raw Javascript
Using native Javascript geolocation api
Decoding JSON
Using Reason libraries such as bs-fetch and bs-json
Fetching data from rest api
React useState
Handling React forms in Reason

Webpack Setup

I felt that the webpack configuration deserved it's own dedicated video.

Tutorial

Resource Links

Build a Typing Speed Test with React Context

Kelvin Mai — Mon, 08 Jun 2020 16:30:23 +0000

In this video we create a typing test application that captures the typing speed in the form of WPM using the react context api and hooks to manage it's state.

Note: I fail to mention this in the video, but wpm is calculated with the average word being 5 characters.

Examples Using Recoil State Management

Kelvin Mai — Tue, 19 May 2020 07:30:22 +0000

Facebook has recently released a brand new state management library for React and I wanted to go over some examples on how to use it.