DEV Community: AbdlrahmanSaber

Convert enum to string literal union type in TS

AbdlrahmanSaber — Sat, 29 Oct 2022 14:40:44 +0000

Hello everyone, this is a quick tutorial, In my work, I wanted to avoid duplicating code as I can and abstract things for example if I use an enum named Weekdays and it contains the following data:

enum Weekdays = {
    MONDAY = 'mon',
    TUESDAY = 'tue',
    WEDNESDAY = 'wed'
}

Let's say you want to create a type called WeekdayType which should contain 'mon' | 'Tue' | 'Wed', how we can do this? Starting from version 4.1 you can do a tricky thing to do it in a single line of code, let's see it.

type WeekdayType = `${Weekdays}`;
// WeekdayType = 'mon' | 'Tue' | 'Wed'|

Congratulations, you did it! Awesome, right?

Take me back, please!

AbdlrahmanSaber — Sun, 24 Apr 2022 16:28:46 +0000

Not your best day. You made changes you shouldn’t have and now everything is broken… Is there a way to undo those commits?

Git keeps track of updates to the tip of branches using a mechanism called reference logs, orreflogsMany Git commands accept a parameter for specifying a reference or “ref”, which is a pointer to a commit. Common examples include git checkoutor git reset.

git reflog

you can get the record of all the commits done in Git.

Now you just need to find the commit prior to the one that caused all the hassle. HEAD@{index} represents the specified commit, so just replace the index with the correct number and run:

git reset HEAD@{index}

The default action for git reset is git reset --mixed. It means that the changes in your working directory will be preserved but not staged (since the index was modified to match the chosen commit, the changes are not in the index anymore).

Other options are:

# Doesn’t modify the index or the working tree, leaving your changes staged for commit.
git reset --soft

# Use with caution, as it resets both the index and working tree. Uncommitted changes and all commits after will be removed.

git reset --hard

And now, you can start over from the point when everything in your repository worked like a charm. Remember to use it only locally, as modifying a shared repository is considered a serious crime.

If you found this post useful please share it with your friends 😍

Let’s connect on LinkedIn, Twitter

How view branches sorted by date in specific format and order

AbdlrahmanSaber — Thu, 21 Apr 2022 03:13:20 +0000

This a short tutorial from a git tricks series.

Let's know how we can list all branches sorted by date.

View branch sorted by date

display a list of all local branches and sort them based on the date of their last commit.

# sort desc (-committerdate)
git branch --sort=-committerdate

# sort asc (committerdate)
git branch --sort=-committerdate

If you’d like to make a custom format you can use for-each-ref with --sort option and --format option to write your format.

git for-each-ref --sort='-committerdate' --format='%(refname)%09%(committerdate)' refs/heads

In the above command, I print the refname first then commitdate in --format option the output will be like this

refs/heads/branch_name commitdate
refs/heads/branch_name2 commitdate

# real output
refs/heads/new_design   Wed Apr 20 12:24:21 2022 +0200

refs/heads/design_assets        Wed Apr 20 11:30:30 2022 +0200

If you want to print the date first then refname, the option format will be like this --format='%(committerdate)%09%(refname)%'

Let’s say you don’t want to print refs/heads and want print just the branch name each time, how we can do this? by using sed.

git for-each-ref --sort='-committerdate' --format='%(refname)%09%(committerdate)' refs/heads | sed 's-refs/heads/--'

#output
branch_name commitdate
branch_name2 commitdate

#real output
new_design      Wed Apr 20 12:24:21 2022 +0200

design_assets   Wed Apr 20 11:30:30 2022 +0200

I find these commands incredibly helpful when returning to work from a weekend or just jumping from project to project. Hopefully, you can use these commands too!

If you found this post useful please share it with your friends 😍

Let’s connect on LinkedIn, Twitter

Is it possible to create a commit with a different date?

AbdlrahmanSaber — Wed, 20 Apr 2022 04:02:32 +0000

This a first short tutorial from a Git Tricks series.

Sometimes, you might run into a situation where you need to create a commit with a different date than the current one. Luckily, you can handle this using following timestamp in git

GIT_AUTHOR_DATE
GIT_COMMITTER_DATE

you might be now you're wondering what's actually the difference between Author and Committer

Let's Understanding dates in Git: author date vs. committer date & ‘approxidate

The author is the person who originally wrote the work, whereas the committer is the person who last applied the work.

So if, for instance, you send in a patch to a project, the author date will be when you made the original commit but the committer date will be when the patch was applied. Another common scenario is rebasing: rebasing will alter the commit date, but not the author date.

The Command


GIT_AUTHOR_DATE='Mon May 18 19:32:11 2022 -0400' \
  GIT_COMMITTER_DATE='Mon May 18 19:32:11 2022 -0400'\
  git commit -m 'Commit from the past'

As shown in the example above, you can set both values to any date you like and your code will be committed on that date.

Note
you can also use other formats

Date formats

RFC 2822 Mon, 18 May 2022 19:32:11 -0400
ISO 8601 2022-05-18 19:32:11 -0400
local Mon May 18 19:32:11 2022
short 2022-05-18
relative 5.seconds.ago, 2.years.3.months.ago, 6am yesterday

Let’s connect on LinkedIn, Twitter

How organize big projects in Laravel?

AbdlrahmanSaber — Tue, 19 Apr 2022 08:20:41 +0000

Agenda

Introduction
What’s HMVC?
Advantages of using HMVC?
What’s wrong with the MVC pattern?
Let’s know how we can use the HMVC pattern in Laravel!
Pros
Cons
Best Packages that generate modules and implement that approach
Conclusion

Introduction

Everyone when beginning a new project starts to ask himself/herself the following question?

How can I make organized the project well to be easy for me or for any other developer easy to understand for example if you’re looking for a file in a big project, you want to be easy to find that file, right?

We have many approaches and design patterns that make the project clean but in this article, I will talk about HMVC (the Hierarchical-model-view-controller) pattern which makes your application modular.

What’s HMVC?

The HMVC pattern extends the MVC pattern and is a solution to overcome scalability problems apparent within large MVC applications.

An HMVC application operates using a collection of MVC entities where each MVC entity can execute without the presence of any other. Ideally, each entity should never load models or libraries of other entities.

Advantages of using HMVC?

HMVC supports the reuse of code
HMVC allows easy distribution of MVC entities stored in a single directory.
HMVC reduces dependencies and allows to easily extend applications while retaining ease of maintenance.
Testing is easier because the system is divided to a large extend into independent parts.

What’s wrong with the MVC pattern?

The Model-View-Controller (MVC) paradigm remains one of the more enduring patterns. However, the traditional MVC scope falls short when it comes to the control of GUI elements (widgets). MVC does not handle the complexities of data management, event management, and application flows.

HMVC provides a powerful yet easy-to-understand layered design methodology for developing a complete presentation layer.

Let’s know how we can use the HMVC pattern in Laravel!

Let’s assume we have an accounting project that has (Banking — Sale— Transaction), the question now is how we can organize the project using HMVC! let’s divide these three parts into MVC components so you can have each of them separately developed but used as one!

Example from a real accounting project

Each module has its own (routes - middleware - controllers- etc..), and it’s help you to make your project more organized.

Pros

Modularization: reduction of dependencies between the disparate parts of the application.
More organized: having a folder for each of the relevant triads makes for a lighter workload.
Reusability: by the nature of the design it is easy to reuse nearly every piece of code.
Extendibility: this makes the application more extensible without sacrificing ease of maintenance.

Cons

Create More Folders But the solution of it in my opinion that we will remove unused folders.

Best Packages that generate modules and implement that approach

we have many packages with Laravel that generate modules but I will share in this article my own package (Laragine) and other packages that I used in many projects.

Laravel Modules

Is a Laravel package that was created to manage your large Laravel app using modules.
This package just structures your project (Modules) and doesn’t provide any implementation.

Laragine

is a Laravel package that was created to manage your large Laravel app using modules also but here’s a difference, this package implements all API CRUD operations with unit tests, the package generates (Controller — Model — Factories — Migrations — unit tests — etc..), all you need to do to just add your API route in your route folder and everything (APIs CRUD operations) will work magically sounds interesting, right!
check this video to know more.
I wrote a series of blogs about it you can check it from here https://dev.to/abdlrahmansaberabdo/series/14891
Check the documentation

Conclusion

Basically, the HMVC pattern is just an extension of MVC. An HMVC application includes one or more MVC sub-applications. so anything MVC can do, HMVC can do too. Now, it depends on whether you need the flexibility and scalability that HMVC offers.

Let’s connect on LinkedIn, Twitter

Do we have pointers in python like other programming !

AbdlrahmanSaber — Wed, 16 Feb 2022 09:21:22 +0000

Pointer is important to understand for the way you’re going to create data structures.

I’m going to start with something that is not a pointer and then compare it to something that does use a pointer.

Let’s say that we have two variable num1, num2

num1 = 11, 
num2 = num1

print("Before: ")
print(num1) #11
print(num2) #11

# then let's change num1

num1 = 22

print("\nAfter\n")
print("num1 =", num1) #22
print("num2 =", num2) #11

If you realized num2 is still the same 11, you’re wondering now why num2 still equals the same number, is it should update to 22 because we update num1!

So when you set num1 = num2, these are not linked forever, you are just initializing, and that is what happens when you’re working with something that is not using a pointer.

Now, let’s compare this to something that does use a pointer.

We’re going to use a dictionary in python, when you have something set equal to a dictionary, it’s a pointer to the dictionary.
Let’s use the same example and see.

dict1 = {
    'value': 11
}

dict2 = dict1

print("Before: ")

print("num1= ", dict1) # {value: 11}
print("num2= ", dict2) # {value: 11}

dict1['value'] = 22

print("\nAfter\n")

print("num1= ", dict1) # {value: 22}
print("num2= ", dict2) # {value: 22}

so when you set dict2 = dict1 , you are literally saying dict2 points to the exact same dictionary in memory as dict1.

There are a couple of other concepts I want to show here.

The first concept is, let’s just say we have another dictionary called dict3

dict3 = {'value': 57}

dict2 = dict3

print (dict2) # {value: 57}

The pointer can be redirected like this also, and this idea of having a pointer point to a new place is a concept that you’ll use in a data structure.

The second concept is, let’s say now we set dict1 = dict2 now all variables (dict1 — dict2 — dict3)
are pointing to {'value':57} so you might ask now, what happens to that dictionary {'value': 22} which is the old value for dict1 before pointing to dict3. is not a way to get that pointer again {'value': 22}? yes no way to get this pointer again, now we should ask what python does to free this memory up?

Good question, python will run a process called garbage collection to remove this.

If you like the post leave a comment and tell me if you’d like to make a series of posts about data structure and how we can use pointers in it.

Let’s connect on LinkedIn

Understand how the views work in Laragine (a package in laravel)

AbdlrahmanSaber — Wed, 06 Oct 2021 22:29:36 +0000

In the previous tutorials we created a fully CRUD API with unit tests, in this tutorial we'll understand how to work with views in Laragine.

When we installed Laragine in the previous tutorial, it's created under the core folder as we know, and also it has created a folder called the Base, we can't discuss everything in the Base folder in this tutorial, but I'll explain it separately.

under Base folder there are two folders called views - unit_template.

In the views folder there's a folder called layout, in layout folder you should create the base views for your website like navbar sidebar - buttons - etc..

What's `unit_template` for, in `core\Base`?

let's assume that you'll create a blog, the blog has units like post - comment - like, each unit will have get - store - update - delete methods, right?

So each unit will have a form for creating - update and a page for showing all units - specific unit, so in each unit, you'll create these files and implement it, instead of creating the views each time in the unit you can put the default views that will be in each unit like form - table - show page and when create a unit you'll just add the non-common other stuff like attributes - titles - etc.. in the form - table - show page - etc.. and make minor changes depends on your project and your way.

let's go to the unit_template folder in core\Base you'll see five files _form - create - edit - index - show you can remove the current code it's just an example and put your own code inside it and make a style for it. you might be thinking now how can I use these files!

Note

Please take a look at the blade files inside core/Base/views and core/Base/unit_template you will notice that $global variable is shared across all the views, the $global variable will help you to load views - route dynamically.
I'll make seperated tutorial about the $global variable

I'll edit the _form file as an example in core/Base/unit_template

Let's create a new unit called comment under blog module
Blog module that we created in the previous tutorial
php artisan laragine:unit comment --module=blog --init
now I'll not discuss what we should do with JSON file if you don't know please see previous tutorial number (1)
Let's run the second part of unit command
php artisan laragine:unit comment --module=blog
let's go to core\Blog\views\comment
if you remember I have just updated the _form file in core/Base/unit_template let's see it in the views in comment unit

it's the same code that I put in the _form file in the core/Base/unit_template folder, right? so we can conclude that each unit will copy the code under the core\Base\unit_template folder.

What're the benefits?
You might be wondering now what're the benefits of doing this, you don't need to write the same code each time in default files in each unit like forms - tables - shows page, you will just put your template with all style then the views will be created automatically for you, then you'll just write other stuff like attributes - titles - etc.. inside them.

*I mean by saying attributes the name of attributes in your table let's say when creating a _form view, you'll need to create new inputs for each attribute like title - body - etc..

Now let's put a route for views

go to core\Blog\routes\web.php and add Route::resource('comments', 'CommentController')->except([ 'store', 'update', 'destroy' ]);

Testing

now let's test the view, you can run php artisan serve to create http-server for your project HTTP-server will listen to port 8000
let's go to http://localhost:8000/admin/commentsmain domain - route

The style is not our main goal in this tutorial I just want to teach you how to work with views in Laragine, you can navigate to any route you want for comments.

let's go to http://localhost:8000/admin/comments/create

If you realized my template appears as I edited in the _form file which is just My Form text.

That's all the basic usage of Views in Laragine,
have fun experimenting in Laragine

How to use Unit tests in Laragine

AbdlrahmanSaber — Mon, 04 Oct 2021 19:04:20 +0000

In the previous tutorial, I taught you how to create a fully CRUD API, let's continue the journey and learn how to use Laragine to test the API that we created in the previous tutorial.

Steps:

We need to do 3 things in phpunit.xml in the root directory:

Change the value of the bootstrap attribute to vendor/yepwoo/laragine/src/autoload.php in PHPUnit tag (it's the same as vendor/autoload.php but with needed stuff to run the tests correctly in the generated modules and units).
Add the following to the Unit test suite:

<directory suffix=".php">./core/*/Tests/Feature</directory>
<directory suffix=".php">./plugins/*/Tests/Feature</directory>

add the following to Feature test suite:

<directory suffix=".php">./core/*/Tests/Feature</directory>

<directory suffix=".php">./plugins/*/Tests/Feature</directory>

*Here's the full code snippet: *

Let's go to PostTest.php in core/Blog/Tests/Feature
There're five main functions in the file:
testItShouldGetListingOfTheResource() for testing get the lists of the the resource.
testItShouldStoreNewlyCreatedResource() for testing create a new resource in the storage.
testItShouldGetSpecifiedResource() for testing get a specefied the resource.
testItShouldUpdateSpecifiedResource() for testing update a resource in the storage
testItShouldRemoveSpecifiedResource() for testing remove a resource from the storage

Note

you can edit the unit tests function as you want, we just write the main methods for each CRUD.

Now open your terminal or git bash in your project and let's run the test, you can run one of the following commands:

php artisan test
./vendor/bin/phpunit

Conclusion

I hope you found this article helpful. If you need any help please let me know in the comment section.

Let's connect on LinkedIn

How to create a fully crud API without implementing the CRUD functions in laravel!

AbdlrahmanSaber — Mon, 04 Oct 2021 17:55:37 +0000

Good day, today we are going to build a fully CRUD system (Web & API). API is a software intermediary that allows two applications to talk to each other. Somethings you might need to create an app that can be run on different languages or frameworks, for example, you can use Laravel to create the backend for your application while the frontend might run on any JavaScript frameworks. API allows two or more programs to communicate with each other.
There are different types of APIs, but today we are going to concentrate on RESTful APIs. REST stands for Representational State Transfer, while API stands for Application Programming Interface. You can read more about API from the internet or other programming material.

Click on my profile to follow me to get more updates.

Prerequisites

We'll use a laravel package called Laragine, this package helps us to create a fully CRUD system by just writing simple commands Without saying much, let's dive into it.

What is Laragine?

Laragine is a laravel package which was created to manage your large laravel app using modules, let's say that you'll build a blog the blog consist of (post - comment - like), blog-> is a module, (post - comment - like) -> called units *laragine built the module & units with all CRUD functionalities also built *(Migrations - factories - tests - controllers - models) all you have to do is to just include the link in route files, awesome, right!

In this tutorial, we'll just create a post for a blog with fully CRUD functionalities so we'll create a module called blog then we'll create a unit called post

STEP 1: install laravel 8

To install the latest laravel framework, which is laravel 8.0 as of the time of publishing this article, run the command below
composer create-project --prefer-dist laravel/laravel laravel_8
This will automatically create a laravel 8 app and some couple of things have been set up, we don’t need to copy and rename the env.example file, Laravel 8 does that automatically for us.

Another important thing about Laravel 8, you don’t need to generate APP_KEY, this new version will also generate it for us.

With that all set up, our app is ready.

STEP 2: Database setup

Create an empty database, Open the .env file, and update your database configurations.

STEP 3: Require Laragine package

Let us install Laragine.

composer require yepwoo/laragine

STEP 4: Install the package

After including Laragine, you have to install it by running the following command:
php artisan laragine:install
it's an initial command for Laragine

Note

After running the command, the Laragine directory will be in the root directory under core directory.

If you want to know more information about the package visit the documentation

STEP 5: Create a blog module

Run the following command and specify the name of the module in our case will be blog
php artisan laragin:module blog

Any module will be added under core directory After running the command, the **blog** directory will be in thecore` directory.

STEP 6: Create unit

After creating our module (blog) we need to create a post, right?
The unit command consists of 2 commands
Init command:
Creates all basic files and will create a JSON file that we'll specify the attributes that we want to add it to the database, we should specify the name of the module that we want to add the unit under it, which is blog in this example.

Second command:
it's the same command without init option, the command will automatically create all the following files depending on the data that we specified in the JSON file.

Migration
Requests
Resources
Factories
unit tests

let's run the commands, we should specify name of the module that we want to create the unit under it & the name of unit

php artisan laragin:unit post --module=blog --init

We include --init because it's the first part of unit command
After running the command it'll generate the basic files Controller (API - web) - Model & also the JSON file that we'll write our attributes in it.

Now we should specify our attributes in the Post.json file, let's first know what the attributes that we need! let's start with the basics in this article I just want to show you how to use the package, you can add any amount of attributes you want, any post have title, body, thumbnail

Note

if we don't put the attribute as nullable will be required by default

Attributes:

title -> type: string, definition: unique
body -> type: text,
image -> type: string, definition: nullable

Now let's go to the JSON file which is in core/blog/data/Post.json to write our attributes.

Note

we should follow rules when writing any attribute in JSON file, there are two types of configuration type & definition

type: is the type of attribute you should write it as Laravel specified in docs you can check all types in Laravel from here
definition: is for column modifier also you should write it as `Laravel specified in the docs you can check it from here

if you realized that I didn't write required because the package will add it automatically.

Let's run the second part of `unit command`

php artisan laragin:unit post --module=blog

After running the command it'll generate migrations - requests - resources - factories - unit tests - etc... files and they are fully implemented.

let's see the migration file, you'll see all attributes are added automatically with the configuration that we specified in JSON file, magic, right🧐!

Now let's run migrate command php artisan migrate

STEP 7: Add API route

add Route::apiResource('posts', 'PostController'); in api.php in core\Blog\routes\api.php

Note

we don't need to implement CRUD methods, it's aleardy implemented in PostController in core\Blog\Controllers\API\PostController.

STEP 8: Testing

open Postman or any other software you use to test the API
let's first create a new post
let's create another post but without including the title to just test if it'll return error or not
Now you're wondering how it gives us that the title attribute is required, right 🤔? let's see PostRequest file in core/Blog/Requests, all attributes that we specefied is in the file with some validation, Laragine does this job for us.

note

you can modify any attribute you want in request file or in any other file Resources - unit test - etc...

Let's get all posts
Let's update the post
before testing update method, you may want to change the validation in the update request (put) and you can do this from PostRequest in core/Blog/Requests file in put method

Let's delete the post

Conclusion

in this article I just showed you one feature of Laragine package, in the next tutorial I'll teach you how to use
unit tests by just making a small configuration.

Let's connect on LinkedIn

DEV Community: AbdlrahmanSaber

Convert enum to string literal union type in TS

Take me back, please!

How view branches sorted by date in specific format and order

View branch sorted by date

Is it possible to create a commit with a different date?

Let's Understanding dates in Git: author date vs. committer date & ‘approxidate

The Command

Date formats

How organize big projects in Laravel?

Agenda

Introduction

What’s HMVC?

Advantages of using HMVC?

What’s wrong with the MVC pattern?

Let’s know how we can use the HMVC pattern in Laravel!

Pros

Cons

Best Packages that generate modules and implement that approach

Laravel Modules

Laragine

Conclusion

Do we have pointers in python like other programming !

Understand how the views work in Laragine (a package in laravel)

What's unit_template for, in core\Base?

Note

Now let's put a route for views

Testing

How to use Unit tests in Laragine

Steps:

Note

Conclusion

How to create a fully crud API without implementing the CRUD functions in laravel!

Prerequisites

What is Laragine?

STEP 1: install laravel 8

STEP 2: Database setup

STEP 3: Require Laragine package

STEP 4: Install the package

Note

STEP 5: Create a blog module

STEP 6: Create unit

Note

Attributes:

Note

Let's run the second part of unit command

STEP 7: Add API route

Note

STEP 8: Testing

note

Conclusion

What's `unit_template` for, in `core\Base`?

Let's run the second part of `unit command`