DEV Community: Dmytro Werner

I don’t have to remember git commands - I built an AI Git Navigator to do them for me 🧭 🤖

Dmytro Werner — Tue, 10 Feb 2026 19:30:18 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

Let’s be honest.

I don’t really remember all git commands and usually have to google if I want to revert some changes or make cherry-picking or something like this.

“I just want to revert the last commit… but on that branch… without breaking prod… please.”

So I built Git Navigator — an AI-powered CLI that turns natural language into safe, reviewable git commands.

The Idea

What if you could just say:

Please revert last commit from branch release/1

And your terminal replied:

“Cool. Here’s what I’m about to do.
Take a look. Breathe. Confirm.”

That’s Git Navigator.

What Is Git Navigator?

Git Navigator is an AI-powered CLI that:
Accepts natural language instructions
Converts them into structured git operations
Builds a step-by-step execution plan
Shows risk level
Runs in dry-run mode by default
Asks for confirmation before doing anything dangerous

In short:
You describe what you want
The tool figures out how to do it — safely

Example

gitnavigator -m = "Please revert last commit from branch release/1"

Output:

🧭 Git Navigator

Proposed plan:
1. Switch to branch release/1
   git checkout release/1
2. Revert last commit
   git revert HEAD

Risk level: high

Dry-run mode. No commands executed.

Demo

revert commits

create new branch

Architecture

Natural language
   ↓
AI (Copilot)
   ↓
Structured intent (JSON)
   ↓
buildPlan.ts
   ↓
Concrete git commands
   ↓
Execution

Installation and Local (Development)

npm install
npm run build
npm link

After linking, the CLI becomes globally available:

gitnavigator --help

Code

Yordaniss / git-navigator

🧭 Git Navigator

Git Navigator is an AI-powered CLI tool that converts natural language instructions into safe, structured, and executable git commands.

You describe what you want to do.
Git Navigator figures out how to do it — safely.

✨ Features

🧠 Natural language → git commands
🧭 Step-by-step execution plan
🔍 Dry-run mode by default (safe preview)
⚠️ Risk level estimation for each operation
✅ User confirmation before execution
🤖 AI-powered intent interpretation (GitHub Copilot / LLM)
🛡 Designed for real production repositories

📦 Installation

Local (Development)

npm install
npm run build
npm link

After linking, the CLI becomes globally available:

gitnavigator --help

🚀 Usage

Basic usage (dry-run)

gitnavigator -- "Please revert last commit"

📝 By default, Git Navigator runs in dry-run mode and does not execute any git commands.

Execute commands

gitnavigator -- "Please revert last commit from branch release/1" --apply

You…

View on GitHub

My Experience with GitHub Copilot CLI

While building Git Navigator , GitHub Copilot CLI played a very specific and intentional role:
it was used as a planning assistant, not as an execution engine.

Instead of asking Copilot to run commands directly, I used it to translate natural language intent into structured JSON instructions. This allowed me to keep full control over execution logic while still benefiting from Copilot’s language understanding.

What Worked Well

Intent interpretation
Copilot CLI was very effective at understanding vague or high-level instructions like
“Please revert last commit from branch release/1” and turning them into actionable intent.
Consistency with a strict prompt
By enforcing a system prompt that allowed only JSON output, I was able to reliably parse responses and avoid hallucinated explanations or unsafe commands.
Fast iteration
Using Copilot CLI directly in the terminal made it easy to iterate on prompts and immediately see how small prompt changes affected the output.

This forced me to design a clear separation:

Copilot plans
The CLI decides
The user confirms

Final Thoughts

Git Navigator is here to meet developers where they are — thinking in intent, not syntax.

If you’ve ever:

Googled “how to revert last commit”?
Panicked after pressing Enter?
Or whispered “please work” to your terminal…?

This tool my be for you.

Thanks for reading — and happy navigating 🧭 ⛴

Feedback and contributions are more than welcome!

P.S. Covered image was generated by dev.to platform ;-)

🔐 Permission Testing Toolkit — Build, Validate, and Ship Secure Authorization with Permit.io

Dmytro Werner — Fri, 02 May 2025 20:45:33 +0000

This is a submission for the Permit.io Authorization Challenge: Permissions Redefined

What I Built

Permission Testing Toolkit is a CLI utility built with TypeScript that allows teams to validate, simulate, and test their fine-grained access control logic using Permit.io.

✅ It supports both manual test cases via JSON and dynamic test generation using your live Permit.io schema.

✅ It’s perfect for CI pipelines or security-conscious teams that want to "test their policies before they break production."

✅ Oh — and it looks nice in your terminal too. 🎨

You write the rules. This CLI makes sure they're followed.

Demo

$ npm start

  ____                            ____ _               _    
 |  _ \ ___ _ __ _ __ ___        / ___| |__   ___  ___| | __
 | |_) / _ \ '__| '_ ` _ \ _____| |   | '_ \ / _ \/ __| |/ /
 |  __/  __/ |  | | | | | |_____| |___| | | |  __/ (__|   < 
 |_|   \___|_|  |_| |_| |_|      \____|_| |_|\___|\___|_|\_\

Running tests from config: test-cases/perm-config.json

📝 Permission Test Report:
========================================
1. Viewer can read a post
   ➤ User: viewer
   ➤ Resource: post
   ➤ Action: read
   ➤ Expected: allow, Actual: allow
   ➤ ✅ PASS

2. Editor cannot delete a post
   ➤ User: editor
   ➤ Resource: post
   ➤ Action: delete
   ➤ Expected: deny, Actual: deny
   ➤ ✅ PASS

✔️  2/2 tests passed.

perm-config.json:

{
  "tests": [
    {
      "user": "admin",
      "resource": "post",
      "action": "delete",
      "expected": "allow"
    },
    {
      "user": "editor",
      "resource": "post",
      "action": "delete",
      "expected": "deny"
    }
  ]
}

Output example:

...
Check delete for viewer
   ➤ User: Sam Smith
   ➤ Resource: Document_number_1
   ➤ Action: delete
   ➤ Expected: allow, Actual: deny
   ➤ ❌ FAIL
...
Summary:
✔ Passed: 4
✘ Failed: 4
Total: 8

Global CLI installation:

npm install -g .
perm-check --config path/to/perm-config.json

Project Repo

Yordaniss / permission-testing-toolkit

🚦 Permission Testing Toolkit

Permission Testing Toolkit is a blazing-fast CLI tool that helps developers automatically test access rules (RBAC/ABAC) configured in Permit.io across multiple users, resources, and actions — using both custom test cases and live schema introspection.

✅ Built with performance, automation, and CI/CD integration in mind — no UI needed.

📦 Features

✅ Custom Permission Tests — Define explicit test cases for users, actions, and expected results.
🚀 Live Schema Introspection — Auto-generate permission tests based on your Permit.io policy schema.
🧠 Role Coverage Testing — Dynamically test every role against every action on every resource.
💥 CI/CD Friendly — Easily integrate into pipelines to prevent policy regressions.
🛠️ Developer-First — CLI-only experience, blazing-fast, fully written in TypeScript.

📸 Demo Output

$ npm start
  ____                            ____ _               _    
 |  _ \ ___ _ __ _ __ ___        / ___| |__   ___  ___| | __

…

View on GitHub

The README walks you through setup, usage, .env configuration, live schema fetching, and creating your own test cases.

You can even install the CLI globally using npm install -g . to run perm-check from anywhere.

My Journey

When I started, my goal was to not just use Permit.io for auth, but to test and trust my auth.

Highlights:

Built a CLI using commander + chalk for clean UX.
Added support for:
- .json config file tests (great for version control)
- Live schema inspection via @permit.io/sdk (dynamic users/actions/resources)
Created a readable, colorful terminal test report 📊
Packaged everything into a globally installable CLI

Challenges & Lessons:

Learned how the Permit.io API & SDK expose actions/resources
Discovered the value of “failing fast” in access control testing

Using Permit.io for Authorization

This CLI interacts with Permit.io in two major ways:

Static Testing:

Load test cases from a .json config and check allow/deny against Permit.io’s PDP (Policy Decision Point) via REST.
Dynamic Schema Testing:

Use the SDK to fetch all defined users, resources, and actions in your Permit.io project. Then simulate permission checks across the board.

📦 Future Potential
This project is not just a utility — it’s the foundation for a permission validation library that could:

Be published as an NPM package
Integrate into CI pipelines (e.g., GitHub Actions)
Visualize permission coverage

🙌 Team or Solo
This was a solo project.

Huge thanks to Permit.io and DEV.to for organizing this challenge and providing excellent documentation and tooling.
This experience was both rewarding and empowering — it not only deepened my understanding of modern authorization workflows but also inspired me to build something perhaps useful for the developer community.

From idea to gift: 🎁 Wish list application with KendoReact 🤺, KI 🤖 & Firebase 💾

Dmytro Werner — Thu, 20 Mar 2025 18:58:42 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

I built a Wishlist App that allows users to:
✅ Create and manage wishlists.
✅ Add, edit, and remove wishlist items.
✅ Mark items as favorites ❤️.
✅ Share their wishlist via a unique link.
✅ Reserve items from shared wishlists.
✅ Get AI-powered gift recommendations 🎯.

Demo

Start page

Wishlist

Get AI Recommendations

Wishlist with AI Response

Share link

Shared wishlist for guests

The code app is under this link:

Yordaniss / wishlist-ai

📌 KendoReact Free Components Challenge Submission

This is a submission for the KendoReact Free Components Challenge.

What I Built 🎁 I built a feature-rich Wishlist App that allows users to:

✅ Create and manage wishlists.
✅ Add, edit, and remove wishlist items.
✅ Mark items as favorites ❤️.
✅ Share their wishlist via a unique link.
✅ Reserve items from shared wishlists.
✅ Get AI-powered gift recommendations 🎯.

This project is designed to help users organize gift ideas for birthdays, holidays, and special occasions while enhancing collaboration with friends and family.

Running the Project Locally

1️⃣ Clone the Repository

git clone https://github.com/YOUR_USERNAME/YOUR_REPO.git
cd YOUR_REPO

2️⃣ Setup the Environment Variables

Frontend Rename .env.example to .env and fill in your Firebase credentials:

REACT_APP_FIREBASE_API_KEY=your_api_key
REACT_APP_FIREBASE_APP_DOMAIN=your_app_domain
REACT_APP_FIREBASE_PROJECT_NAME=your_project_name
REACT_APP_FIREBASE_STORAGE_BUCKET=your_storage_bucket
REACT_APP_FIREBASE_MESSAGING_SENDER_ID=your_messaging_sender_id
REACT_APP_FIREBASE_APP_ID=your_app_id

Backend: Rename .env.example to .env and add your Cloudflare credentials:

CLOUDFLARE_ACCOUNT=your_account_id
CLOUDFLARE_TOKEN=your_api_token

Install Dependencies

Frontend:

cd frontend
npm install
npm start

Backend:

cd backend

…

View on GitHub

Running the Project Locally

1️⃣ Clone the Repository

git clone https://github.com/YOUR_USERNAME/YOUR_REPO.git
cd YOUR_REPO

2️⃣ Setup the Environment Variables
Frontend: Rename .env.example to .env and fill in your Firebase credentials:

REACT_APP_FIREBASE_API_KEY=your_api_key
REACT_APP_FIREBASE_APP_DOMAIN=your_app_domain
REACT_APP_FIREBASE_PROJECT_NAME=your_project_name
REACT_APP_FIREBASE_STORAGE_BUCKET=your_storage_bucket
REACT_APP_FIREBASE_MESSAGING_SENDER_ID=your_messaging_sender_id
REACT_APP_FIREBASE_APP_ID=your_app_id

Backend: Rename .env.example to .env and add your Cloudflare credentials:

CLOUDFLARE_ACCOUNT=your_account_id
CLOUDFLARE_TOKEN=your_api_token

Install Dependencies
Frontend:

cd frontend
npm install
npm start

Backend:

cd backend
npm install
npm start

Your app should now be running! 🎉

KendoReact Experience

KendoReact played a major role in making this wishlist app functional. I used:

✔ KendoReact Buttons: Stylish buttons for adding, sharing, and reserving wishlist items.
✔ KendoReact Inputs: Clean form controls for entering item details.
✔ KendoReact Checkbox: Used for category selection
✔ KendoReact TextArea: Entering some additional text.
✔ KendoReact DropDownList: Easy item categorization.
✔ KendoReact Avatar: Enhancing UI with user-friendly elements.
✔ KendoReact Chip: UI Component for favorite icon
✔ KendoReact Notification: Displaying alerts and updates.
✔ KendoReact ProgressBar: Showing AI recommendation loading state.
✔ KendoReact Animation: Smooth transitions for adding/removing items.

And also some icons in navigation:
✔ KendoReact homeIcon
✔ KendoReact SvgIcon

AIm to Impress

This app integrates AI-powered recommendations 🎯 using Cloudflare API to suggest personalized gift ideas based on the wishlist contents.

🛠 How it works:
1️⃣ The user clicks "Get AI Recommendations."
2️⃣ The app sends wishlist data to the AI-powered API.
3️⃣ The AI analyzes preferences and suggests new gift ideas.
4️⃣ The recommendations appear in a KendoReact Notification panel.

🔍 This feature leverages AI to enhance user experience by providing smart, tailored gift suggestions.

Team Submissions

Worked alone during this project.

🚀 Final Thoughts
🎉 This project showcases how KendoReact Free Components can be used to build a fully functional, AI-powered wishlist.

Big thanks to KendoReact for this challenge! Looking forward to exploring more KendoReact features in future projects. 🚀

Patient Management and Recommendation System with AssemlyAI and CloudflareAI 🏥👩‍⚕️👨‍⚕️

Dmytro Werner — Fri, 22 Nov 2024 18:52:10 +0000

This is a submission for the AssemblyAI Challenge : Sophisticated Speech-to-Text.

What I Built

I built a Patient Management and Recommendation System that streamlines medical data collection and provides tailored health recommendations based on patients' symptoms. The application allows users to upload audio recordings of patient details and symptoms, which are transcribed into structured text using AssemblyAI’s advanced Speech-to-Text API. The system then parses this information, categorizes the symptoms, and displays personalized recommendations for treatment using CloudflareAI.

Key features:

1. Audio-to-text transcription using AssemblyAI.
2. Symptom analysis and tailored treatment recommendations using CloudflareAI Worker.
3. Clean and intuitive user interface for managing patient data.
4. Hosted in a Dockerized environment with a PostgreSQL database for persistent storage.

Demo

The code app is under this link:

Yordaniss / healthcare

Patient Management System

This project is a Patient Management System designed to handle patient records, process audio inputs for medical transcription, and provide symptom-based treatment recommendations. The application leverages modern React components for the frontend and integrates APIs for intelligent analysis.

Features

Core Functionality

Patient List View:
- Displays a list of all patients with their summaries in a responsive, card-based layout.
- Allows users to browse and view patient details.
Patient Details View:
- Displays comprehensive information about a patient, including:
  - Name
  - Age
  - Recorded symptoms
  - Date of consultation
  - Transcription and parsed medical recommendations.
File Upload:
- Accepts audio files for transcription.
- Automatically updates the patient list with new data upon successful file upload.

Intelligent AI and Audio Processing

AssemblyAI Integration:
- Converts audio files into text using the AssemblyAI transcription service.
- Extracts meaningful details such as
  - Patient name
  - Age
  - Symptoms
  - Consultation date
Cloudflare AI Integration:
- Processes symptoms via Cloudflare…

View on GitHub

Patient list including audio upload:

Patient details:

Journey

This project was designed to simplify managing patient records and generating personalized health recommendations. The goal was to streamline the workload for healthcare professionals by enabling them to record audio notes about patients and extract key information automatically. For example, a doctor seeing multiple patients in a day can simply upload an audio file, and the application will process it to extract critical data like the patient's name, age, symptoms, and recommended treatments—saving time and ensuring accuracy in record-keeping.

How AssemblyAI Was Used

Audio-to-Text Transcription:

Audio-to-Text Transcription:
Using AssemblyAI’s API, uploaded audio files containing patient details (e.g., "Patient Jane Smith, age 29, reporting fatigue and fever") are transcribed into text. The API seamlessly converts diverse medical terms and patient notes with remarkable accuracy.
Data Parsing:
After transcription, key details such as the patient’s name, age, symptoms, and date are extracted using regular expressions and integrated into the database.
Recommendations Engine:
Based on the parsed symptoms, the app provides structured recommendations (e.g., "Rest and hydration," "Over-the-counter medications") using CloudflareAI. These are presented in a clear and accessible format to help users take action.

AssemblyAI Challenge Prompts:

Sophisticated Speech-to-Text Application: Built an end-to-end system that goes beyond transcription to include actionable insights and a user-friendly interface.

Intelligent AI and Audio Processing

AssemblyAI Integration:

Converts audio files into text using the AssemblyAI transcription service.
Extracts meaningful details such as:

Patient name
Age
Symptoms
Consultation date

Cloudflare AI Integration:

Processes symptoms via Cloudflare AI to generate recommendations.

Tools and Technologies

AssemblyAI for transcription.
CloudflareAI for recommendations.
React for the front-end.
Node.js and Express for the back-end API.
PostgreSQL (via Docker) for database management.
CSS for styling the user interface.

Thanks for the opportunity to showcase this project! 😊

AI Interview Prep Helper with PostgreSQL, Ollama, and Open-Source Vector Extensions 🚀

Dmytro Werner — Wed, 06 Nov 2024 21:05:17 +0000

This is a submission for the Open Source AI Challenge with pgai and Ollama

What I Built

I built an AI-powered job skills recommendation application that leverages PostgreSQL and open-source vector extensions to recommend interview questions based on a job description. The application extracts key skills from job descriptions, embeds them as vectors, and stores them in PostgreSQL, allowing for efficient similarity searches. It also provides feedback on user-submitted answers to help applicants improve their responses based on specific feedback criteria.

This project combines text analysis, vector similarity searches, and AI feedback generation, creating a tool that aids job seekers in better preparing for interviews with relevant questions and real-time feedback.

Demo

The code app is under this link:

Yordaniss / interview-prep-helper

AI Interview Prep Helper with PostgreSQL, Ollama and Open-Source Vector Extensions 🚀

Project Overview

This project demonstrates a lightweight AI application that leverages open-source tools, using PostgreSQL as the vector database with AI extensions. By embedding job descriptions and questions into vector format, this application can identify relevant questions based on job requirements, offer tailored question recommendations, and provide AI-generated feedback on responses.

The key tools used in this project include:

PostgreSQL with pgvector for storing and querying vector embeddings.
pgAI for processing and retrieving feedback on user answers.
Ollama as an AI tool for embedding and generating text responses.

Project Components

The application has three primary parts:

Job Description Parsing and Question Recommendation: Given a job description, the application extracts key skills and identifies relevant questions from the database.
AI-Driven Answer Feedback: Upon submitting an answer to a question, the application leverages AI feedback based on correctness, efficiency, code…

View on GitHub

Please follow the instructions to run this locally.

Screenshots:

Job Description Input

Recommended Questions

Feedback on Answer

Additional endpoints to store questions

and get recommended

Tools Used

pgvector
pgvector stores the embeddings for job descriptions and questions, allowing us to query and compare them using similarity searches.
It supports storing high-dimensional vectors and facilitates similarity-based searches within PostgreSQL, enabling the core recommendation functionality of this application.
pgAI
pgAI integrates AI-powered feedback directly within PostgreSQL.
By embedding the feedback process into PostgreSQL queries, pgAI allows our application to evaluate and provide insights on user-submitted answers, scoring them on aspects like correctness, efficiency, and clarity.
Ollama
Ollama is used to generate embeddings and feedback responses.
It processes user queries, generates embeddings for job descriptions and questions, and helps in extracting relevant skills and evaluating answers with custom feedback prompts.

Final Thoughts

This project demonstrates the power of combining PostgreSQL with its AI extensions to build a vector-based recommendation and feedback system without needing an additional vector database. Integrating pgvector, pgvectorscale, and pgAI made it possible to create an efficient, fully open-source AI application with minimal setup.

Prize Categories:

Open-source Models from Ollama

Thanks you! ❤️

Thanks for considering this project, and I hope you enjoy exploring its functionality as much as I enjoyed building it! 🙏

Nylas Mailbox AI Assistant 🤖

Dmytro Werner — Wed, 28 Aug 2024 20:19:07 +0000

This is a submission for the Nylas Challenge: AI Expedition.

What I Built and Why

Hello everyone 🙂
Using Nylas-API and Cloudflare-AI I have build Mailbox AI Assistant to help:

organize your emails 💻
send congratulations to your contacts if they have birthday 🥳
get your next events 🎊
automatically summarize content from email and send the answer to emails, that were not read 📖 🤖
get information, how much emails I have got this week 🗓

Main idea was to automatize minor things, that you could forget, like congratulations or get information about your email and calendar.

Demo

First of all we could get information about emails of the current week. For this one I have used ´queryParams´ from Nylas API:

const messages = await nylas.messages.list({
      identifier,
      queryParams: {
        received_after: Math.floor(startOfWeek.getTime() / 1000)
      }
    });

Second feature is to get contacts and they birthday days. If it is today, add button with functionality to send congratulations according to personal information from your contact, like name and age. This one we get from contacts using Nylas API.

const contacts = await nylas.contacts.list({
      identifier,
      queryParams: {},
    });

Next one is to get events.

   const calendars = await nylas.calendars.find({
      identifier,
      calendarId: "primary",
    });

And now main content with most of codes. So we have emails, that are you did not read.

    const messages = await nylas.messages.list({
      identifier,
      queryParams: {
        unread: true,
      },
    });

You can summarize email content using cloudflare model cf/facebook/bart-large-cnn.

In the next step you can generate the answer using other cloudflare model cf/openchat/openchat-3.5-0106.

If you click send email, generated email will be send to person, that wrote this one.

Code

Yordaniss / mailbox-assistant

Submitting for Nylas AI and Communications Challenge

Using Nylas-API and Cloudflare-AI I have build Mailbox AI Assistant to help:

organize your emails 💻
send congratulations to your contacts if they have birthday 🥳
get your next events 🎊
automatically summarize content from email and send the answer to emails, that were not read 📖 🤖
get information, how much emails I have got this week 🗓

View on GitHub

Your Journey

That was really interesting to use nylas api to get information from my mail account. Best part of this, that you can write directly in your request the queryParams with some conditions, that I have used for getting emails for current week.

Im most proud of finishing the main features of this project and integrating AI text generating with key features of Nylas API.

Most challenging was to create the concept and implement the logic for using AI to summarize and generate response of text. The solution for this was to create generating step by step with possibility to send response if thats ok or regenerate response.

I found documentation of Nylas very good structured and prepared. Very useful was the page with endpoints:
Documentation Nylas

List of models of cloudflare you can find under:
Cloudflare Models

Thanks a lot for organization this challenge. Made me happy to work on this one 🤗

GitHub + DEV 2023 Hackathon! - Github Commit Message Translator 📖

Dmytro Werner — Thu, 11 May 2023 21:15:19 +0000

What I built

I built GitHub action, that automatically translate commit message and pushes the message into GitHub pages using Jekyll for creating documentation or changelog.

Category Submission:

Maintainer Must-Haves

App Link

GithubPage

Screenshots

Description

After each commit, the message, that was written will be translated using Translator-API from mymemory.net. In .yml file, you can define target and source languages. After message was translated, the message will be sent to gh-pages, that is used as "documentation branch". I used Jekyll to create static webpage, that used markdown files for building pages. En voilà, at the end we have translated messages as documentation.

Link to Source Code

Yordaniss / documentation

Github translated commits into gh-pages for documentation/changelog 📖

The project was created to generate translation for commit messages for supporting open source maintainers and repository owners to make it easier to write commit messages in other languages.

Key Technologies

GitHub Pages
GitHub Action
MyMemory API (for translation)
Jekyll

There are two option for languages (source and target language), other information will be got automatically from workflow. The .yml file look like:

name: Translate commit message
on: [push]
jobs
  run-script:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Install Node.js
        uses: actions/setup-node@v2
        with:
          node-version: "18.x"
      - name: Install dependencies
        run: npm install
      - name: Get Commit Message
        id: commit_message
        run: echo "::set-output name=message::$(cat $GITHUB_EVENT_PATH | jq -r '.commits[0].message')"
      - name: Run Script
        run: node action/index.js
        env:

…

View on GitHub

Permissive License

MIT

Background (What made you decide to build this particular app? What inspired you?)

I was thinking, the main idea of open source is to connect people from all around the corner, to build some cool projects. But there are so many languages, so it's sometimes difficult, to describe, what did you do in your commit. In other side this is also important for repository-owner, to get important information about workflow. In the best case as documentation.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I did learn a lot about GitHub Actions and GitHub Pages. For me, it was fascinating to create workflow, that automatically create new content for me. Functionality of "gh-pages" was for also something new to know, especially how does it work with Jekyll integration. I used all this information and of course the functionality of GitHub Actions to build it all in one tool. The information about workflow is also available in README file in my repository.

Additional Resources/Info

GithubPages
GithubJekyll

Searching in JAVA: Elasticsearch vs MySQL vs Hibernate

Dmytro Werner — Wed, 28 Sep 2022 05:57:14 +0000

Hello folks :)

I was thinking lately: if I have logic for searching data in frontend and JAVA for backend, which technology should be used to find data? In this case some search engine would be a good idea. But is it easy to implement? I wanted to try a couple things and compare, which option is the best.
Learning by doing I understood how it works and I´d like to share this experience.

JAVA

First of all we need to create our JAVA application. I used the "Initializr" from Spring to get basic configuration for my project. Spring Initializr

Spoiler!:-D
My end configuration looks like this (Java version 18):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.tutorial</groupId>
    <artifactId>search</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>search</name>
    <description>Tutorial project for search engine</description>
    <properties>
        <java.version>18</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.hibernate.search</groupId>
            <artifactId>hibernate-search-mapper-orm</artifactId>
            <version>6.1.1.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.search</groupId>
            <artifactId>hibernate-search-backend-lucene</artifactId>
            <version>6.1.1.Final</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-elasticsearch</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.3.1</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Then just install all dependencies and we are good to move forward.

mvn install or mvn package

MySQL

Ok, now we need our database and some data. To fetch data we need to have/install mysql to local machine. To make it easier, we could install Workbench
to get also GUI. We need to put information about database(username, password, database url) in application.properties as well.

spring.datasource.url={url_path}
spring.datasource.username={database_username}
spring.datasource.password={database_password}
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Now just type Book model. I also added the annotations we need for our search engines.

Important

A table named book should exist in your database and should include some data for test.

@Entity
@Indexed
@Table(name = "book")
@Document(indexName = "books", type = "book")
public class Book {
    @Id
    private int id;

    @FullTextField
    @Field(type = FieldType.Text, name = "name")
    private String name;


    @FullTextField
    @Field(type = FieldType.Text, name = "isbn")
    private String isbn;

    public int getId() {
        return id;
    }

    public String getIsbn() {
        return isbn;
    }

    public String getName() {
        return name;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Now to get response from request we need Repository class.

public interface BookRepository extends PagingAndSortingRepository<Book, Integer>
{
    List<Book> findByName(String name);    
    List<Book> findByIsbn(String isbn);    
}

And now to get data from url we need a controller. I keep it very simple just to get response and check if data was loaded.

@RestController
@RequestMapping(value = "book")
public class BookController {    
    @Autowired
    BookRepository bookRepository;

    @GetMapping("/database")
    ResponseEntity<Iterable<Book>> getBooksFromDatabase(@RequestParam("query") String query)
    {
        Iterable<Book> booksFromDatabase = bookRepository.findByIsbn(query);

        return ResponseEntity.ok(booksFromDatabase);
    }
}

Ok, it seems to be done with database.

Was not so hard, but this is not most flexible option to interact with a searching flow.

Let´s take a look at the searching engines. We will start with very powerful technology in JAVA.

Hibernate

First we need to create configuration file.

@Component
public class BookIndexConfiguration implements CommandLineRunner
{
    @PersistenceContext
    EntityManager entityManager;

    @Override
    @Transactional(readOnly = true)
    public void run(String ...args) throws Exception
    {
        SearchSession searchSession = Search.session(entityManager);
        MassIndexer indexer = searchSession.massIndexer(Book.class);
        indexer.startAndWait();
    }
}

Over here the indexer from hibernate will create index with data from our model once the application was started. To explore books in index we also need service class. Ok, let's create one.

@Service
public class BookSearchService {
    @PersistenceContext
    EntityManager entityManager;

    @Transactional(readOnly = true)
    public Iterable<Book> search(Pageable pageable, String query)
    {
        SearchSession session = Search.session(entityManager);

        SearchResult<Book> result = session.search(Book.class)
            .where(
                    f -> f.match().
                    fields("name", "isbn").
                    matching(query)
                )
            .fetch((int) pageable.getOffset(), pageable.getPageSize())
        ;
        return result.hits();
    }
}

We have search function that loads a current session and checks in index, if the query matches to the name or isbn. If some objects were found, it will be returned as Iterable of Book objects

And thats it! Was it even easier that typical database call?

Now we need to configure a different search engine.

Elasticsearch

Ok, now we need a little bit more configuration ~~or maybe not~~. Just like in the case with MySQL, we should install Elasticsearch. I will use Docker image to get the client. Alternatively you can use one of the methods under the following link Elasticsearch install

version: '3.7'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.3.2
    container_name: elasticsearch
    environment:
      - xpack.security.enabled=false
      - discovery.type=single-node
    ports:
      - 9200:9200
      - 9300:9300

Important
For testing purposes I disabled the security mode. You should not do this if you deploy your application into the live system.

After Elasticsearch has been installed and started, we can create one more configuration file with Client.

public class BookElasticsearchClient {
    private ElasticsearchClient client;

    public ElasticsearchClient getClient()
    {
        if (client == null) {
            initClient();
        }

        return client;
    }

    private void initClient()
    {
        RestClient restClient = RestClient.builder(new HttpHost("localhost", 9200)).build();

        ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        client = new ElasticsearchClient(transport);
    }
}

If you use authentication with username and password, you need to configure these as well. The information on how to do this, is under the following link: Authentication

Aaaand now service class for searching.


@Configuration
public class BookElasticsearchService {
    BookElasticsearchClient client = new BookElasticsearchClient();

    private static final String BOOK_INDEX = "books";

    public void createBooksIndexBulk(final List<Book> books)
    {
        BulkRequest.Builder builder = new BulkRequest.Builder();

        for (Book book : books)
        {
            builder.operations(op -> op
                .index(index -> index
                    .index(BOOK_INDEX)
                    .id(String.valueOf(book.getId()))
                    .document(book)
                )
            );

            try {
                client.getClient().bulk(builder.build());
            } catch (ElasticsearchException exception) {
                exception.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public List<Book> findBookByIsbn(String query)
    {
        List<Book> books = new ArrayList<>();

        try {
            SearchResponse<Book> search = client.getClient().search(s -> s
                .index(BOOK_INDEX)
                .query(q -> q
                    .match(t -> t
                        .field("isbn")
                        .query(query))),
                Book.class);

            List<Hit<Book>> hits = search.hits().hits();
            for (Hit<Book> hit: hits) {
                books.add(hit.source());
            }

            return books;
        } catch (ElasticsearchException exception) {
            exception.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }
}

These are two very important functions. One of them is to create an index and put data into a document, another one have been used to get information about book from isbn.

And last but not least, we need a repository class for Elasticsearch.

public interface BookElasticsearchRepository extends ElasticsearchRepository<Book, String> {}

In the end we need to complete our controller to send requests.

@RestController
@RequestMapping(value = "book")
public class BookController {    
    @Autowired
    BookSearchService searchService;

    @Autowired
    BookRepository bookRepository;

    @Autowired
    BookElasticsearchService bookElasticsearchService;

    @GetMapping("/database")
    ResponseEntity<Iterable<Book>> getBooksFromDatabase(@RequestParam("query") String query)
    {
        Iterable<Book> booksFromDatabase = bookRepository.findByIsbn(query);

        return ResponseEntity.ok(booksFromDatabase);
    }

    @GetMapping("/hibernate")
    ResponseEntity<Iterable<Book>> getBooksFromHibernate(Pageable pageable, @RequestParam("query") String query)
    {
        Iterable<Book> booksFromHibernate = searchService.search(pageable, query);

        return ResponseEntity.ok(booksFromHibernate);
    }

    @GetMapping("/elasticsearch")
    ResponseEntity<Iterable<Book>> getBooksFromElasticsearch(@RequestParam("query") String query)
    {
        Iterable<Book> booksFromElasticSearch = bookElasticsearchService.findBookByIsbn(query);

        return ResponseEntity.ok(booksFromElasticSearch);
    }
}

One more important thing before starting the application:
we need to add the annotations(see below) in the main ApplicationClass, to make it work with multiple search engine technologies in one application.

@EnableElasticsearchRepositories(basePackageClasses = BookElasticsearchRepository.class)
@EnableJpaRepositories(excludeFilters = @ComponentScan.Filter(
    type = FilterType.ASSIGNABLE_TYPE, value = BookElasticsearchRepository.class
))
@SpringBootApplication
public class SearchApplication {

    public static void main(String[] args) {
        SpringApplication.run(SearchApplication.class, args);
    }

}

Let´s test all the things together.

I also had to create an index in my very first time. I called the function createBooksIndexBulk from BookElasticsearchService. There is also an option to call index directly in Elasticsearch console. How to do this is described here: Bulk Api

I send couple requests (in my database i have an isbn=123test):

http://localhost:8080/book/hibernate?query=123test
http://localhost:8080/book/database?query=123test
http://localhost:8080/book/elasticsearch?query=123test

For each request I got a right response. Mission completed.

Thanks a lot for reading.

Additional resources that I used:

You can also check my Github to get the whole code

Yordaniss / compare-search-engine

Repository to compare search engines for java application

Compare search engine for JAVA

This repository was created to test implementation of popular search engines with directly MySQL loading for JAVA Spring application.

Sources for data loading:

Hibernate Search
Elasticsearch
MySQL

View on GitHub

Github commit searcher

Dmytro Werner — Sat, 27 Aug 2022 07:29:00 +0000

Overview of My Submission

What?
This is basic project to find messages in your commit history.

Why?
I was thinking to create app to get information from my commits if i want to find some important message that was wrote before.

How?
To get information was used Github-API and to run Redis locally was used Docker.

Improvement ideas

use GitHub Actions to update information automatically
save more dat and filter this data in frontend
use advance caching from Redis to increase performance

Submission Category:

~~MERN~~/RERN(Redis,Express,React,Node) Mavericks

Language Used

JavaScript

Tech-Stack

Redis to store data (database)
Redis to search data (search engine)
Node with express (backend)
React (frontend)

Link to Code

Yordaniss / commit-searcher

Commit-Searcher

Small project to search commits from your repository.

Example

How it works

How the data is stored:

After server was loaded data will be stored to Redis database from api endpoint.

There are several steps to:

create Schema like this:

const commitSchema = new Schema(Commit, {

    message: { type: 'text' },

    author: { type: 'string' },

    url: { type: 'string' }

})

get data from your repository:

const response = octokit.request('GET https://api.github.com/repos/{owner}/{repo}/commits', {

    owner: process.env.GITHUB_OWNER,

    repo: process.env.GITHUB_REPO

});

save data to Redis

response.then(function(result) {

    result.data.map((commit) => {

        saveDataToRedis(

            commit.commit.message,

            commit.commit.author.name,

            commit.html_url,

        )

    })

})

create index in Redis:

await  commitRepository.createIndex()

How the data is accessed:

Data will be loaded from server via endpoints to frontend. There you can see all commits and search for data.

Get all data (used search() function from Redis repository)

app.get('/commits', async (req, res) => {

    const commits = await commitRepository.search().return.all();

    res.json(commits)

})

Search messages…

View on GitHub

Licence: MIT

Additional Resources / Info

Github-Api
Docker-Image

Collaborators

Solo project

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.