Create a PHP composer package | How to
Tags: php, opensource
Published: 2021-07-29 19:29:51

Composer packages are a great way of making your code available to everyone. 

It my be a daunting thought to create your first package, but if you break it down into simple steps, it becomes much less scary! Let's see:

1. Create your composer file
2. Register your namespaces and autoloaders
3. Write your code 🥳
4. Push your code to your repository
5. Create a tag or a version
6. Submit your package to Packagist (the repo of composer packages)
7. Done! 

## Your composer file
Naturally, to do this, you should have composer installed. 
To check if you have composer, go ahead and run the below in your command line:
```
composer
```
If you have Composer installed, you'll see:
```
   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 2.0.4 2020-10-30 22:39:11
...
```
If you do not, you'll need to install [Composer](https://getcomposer.org/).

Now that we've got composer, we can create our Composer file. 
To get the ball rolling, just run:
```
composer init
```
This will begin the interactive Composer file creation. 


First you'll see:
```
Package name (<vendor>/<name>) [pc/composer]:
```

This will be the name of your package Few things to note:

- Vendor is the author of the package
- Name is the... name of the package.

Enter your name, for example I will say `joem/tutorial`.

Next you'll be asked for the description of your package. 

After that, you'll be asked for the author. 

You'll then be asked for the min-stability, you can skip this one, as well as `Package Type` and `License`.


You'll see:
```
Would you like to define your dependencies (require) interactively [yes]?
```
Go ahead and enter `n`.

Next:

```
Would you like to define your dev dependencies (require-dev) interactively [yes]?
```
Again, a cheeky `n`.

```
Do you confirm generation [yes]?
```
`yes`!

Fantastic, we've created our Composer file.

## Project structure and namespaces
Typically, you'll see this structure (or similar):

```
project-name (root)
├── composer.json
├── composer-lock.json
├── src
│   ├── ClassName.php
│   ├── helpers.php
├── tests
│   ├── ClassNameTest.php

```

Note: `ClassName.php` is the name of your class!

With this in mind, we can create our autoloaders to load our files. Inside of `composer.json`, add:
```json
"autoload": {
        "psr-4": {
            "Joem\\App\\": "src"
        },
        "files": [
            "src/helpers.php"
        ]
    }
```

inside of your object below `require`. Where `Joem` is the name of your project. Here we are autoloading all classes inside of `src`, with the namespace of `Joem\App`, and loading our helper file. 

Now, let's create our class inside of `src`.
Here is the example class I am using:
```php
<?php
namespace Joem\App;

class ClassName {

}
```

Notice the `namespace Joem\App;`, this means it will be autoloaded into our vendor.

To generate the autoloader, go head and fire:
```
composer dump-autoload
```
into your console.

This will generate an autoloader containing our class and helper file. 

We can now include our autoloader into our files. 

If we make a index.php and add:

```php
<?php

require_once 'vendor/autoload.php';

$class = new \Joem\App\ClassName();

```

We'll see our autoloader is working!

Fantastic 🥳 From here, you can add all the code you would like!

## Git repo

Once your class(es) are ready, we need to attach the code to a git repo, in this case, a Github repo. 

Once you have created you repository and added it to your codebase, you'll need a `.gitignore` in your project root, containing `vendor/`. This will prevent your repository from being filled with Composer dependency gunk. 

Your repo is important, since Packagist will use it to fetch your code. 

You'll need to create a release for your main branch, you can version it as `v1.0.0`, this will prevent min-stability errors when we try to install it later!


## Submitting the package
We will use [Packagist](https://packagist.org/) to submit our package to the Composer repository. 

Head to packagist and create your account.

Once your account is created, click the "submit" button. You will be prompted to enter the URL of your Github repository. Once submitted, your package will be available as a Composer package!

✨ A M A Z I N G ✨

Now, you can install your package through composer with the command

```
composer require joem/tutorial
```

Where `joem/tutorial` is the name of your package, which we inputted when we created the composer file.


## A note on testing
In our structure, you'll see we added a `tests` directory, it is encouraged that your package contains tests, these can be created with a tool such as [PHPUnit](https://phpunit.de/).