
<Box heading="Calling JavaScript from PHP is simple.">

<Content>

There are many use cases for running JavaScript code from PHP. You can server side render a React app, or call upon one of NPM's many libraries. And I'm going to show how simple it is to do!

</Content>

<Content heading="Requirements">

<p>
  1. PHP <br />
  2. Node.js
</p>

You don't need anything out of the ordinary just PHP, and Node.js. Yup 0 external dependencies.

</Content>
</Box>

<Box heading="Sockets">

<Content heading="What are Sockets?">

**Sockets** are inter-process communication mechanisms that allows bidirectional data exchange.

What? Let me break that down.

Lets say we're working on a document in Microsoft Word. You really want to create an integration between Microsoft Word and Node.js, so that you can format a documents content with different predefined JavaScript functions. In lower level terms, what you want is a way for two running processes (Microsoft Word, and Node.js) on the same machine to communicate.

You want to be able to send the content from Microsoft Word, into Node.js. And then once Node.js has completed it's work, to send it back to Microsoft Word.

Kinda sounds like you need an "inter-process communication mechanism that allows bidirectional data exchange". Thats a Socket. Sockets allow communication between two different processes running on the same or different machines.

More particularly, sockets are simply file descriptors, however that is beyond the scope of this article.

</Content>

<Content heading="What is an Unix Socket?">

We are going to use a particular type of socket known as an **Unix Domain Socket** (aka Unix Socket).

An Unix Socket is an inter-process communication mechanism that allows bidirectional data exchange **between processes running on the same machine**.

There are also IP sockets. IP sockets enable communication **between processes on the same or different machines via TCP**. The benefit of an Unix Socket, is that they avoid the overhead of a TCP/IP connection.

Anthony Headings provides a great analogy in his article [What are Unix Sockets and how do they work?](https://www.cloudsavvyit.com/1263/what-are-unix-sockets-and-how-do-they-work/).

<q>
  Sockets are a direct connection between two processes. Imagine if you wanted
  to call your friend down the road; you could place a call have it routed up
  through your telephone company and back down to their house, or you could run
  a wire directly to their house and cut out the middleman. The latter is
  obviously impractical in real life, but in the world of Unix it’s very common
  to establish these direct connections between programs.
</q>

We communicate with a socket through it's socket file. This file is created automatically by opening a socket.

Like I said, a socket is really just a file descriptor. The only point of the socket file is to maintain a reference to this file descriptor, and to control access to the socket through filesystem permissions.

Okay, enough theory.

</Content>

<Content heading="Sockets are Interesting!">

If you'd like to explore this topic further, here's a few great reads.

[Understanding Sockets](https://www.digitalocean.com/community/tutorials/understanding-sockets)  
[What are Unix Sockets and how do they work?](https://www.cloudsavvyit.com/1263/what-are-unix-sockets-and-how-do-they-work/)  
[What is the difference between Unix Sockets and TCP/IP Sockets](https://serverfault.com/questions/124517/what-is-the-difference-between-unix-sockets-and-tcp-ip-sockets)

</Content>

</Box>

<Box heading="Open and Listen on an Unix Socket via Node.js">

<Content>

Before jumping in, let me explain how this all works. We need communicate with a Node.js process from a PHP process.

First, we'll need to start up a Node.js server that opens and listens on an Unix Socket.

Then, we'll connect to this socket from within PHP.

</Content>

<Content heading="Create the Node.js Server.">

So, we need a Node.js server that opens an unix socket and listens for data on it.

Typically when we create a server in Node.js, such as an Express server, we'll have it listen on a port. Well, that port is really just an IP socket. So it's the same idea, we're just using a different kind of socket.

We'll create this file as an executable. Save the following to a file called 'node' in a directory `bin`. No file extension needed, because this is an executable file. Notice the shebang on the 1st line `!#/usr/bin/env node`.

```js
#!/usr/bin/env node

const net = require('net')
const fs = require('fs')
const path = require('path')

// Where to output the socket file.
const socketPath = path.resolve(root, 'var/node.sock')

// If a socket is already open, we'll replace it.
if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath)

// We create a server that accepts a socket to listen on. When the socket receives some javascript, the server will run it through `eval()`.
const server = net.createServer(socket => {
  socket.setEncoding('utf8')

  // We push each chunk of data, into the chunks array.
  // After pushing each chunk we also check if the last character is '\0'.
  // '\0' is a special token, we use to signal that there will be no more content after this. No more chunks.
  // This means, we can eval the data (js) we recieved confident that we aren't missing anything.
  const chunks = []
  socket.on('data', chunk => {
    chunks.push(chunk)
    const lastChar = chunk[chunk.length - 1]
    if (lastChar === '\0') {
      // Okay we found the '\0' token. So we join all the chunks together into one string.
      // We eval() the combined chunks.
      // Then we send the result back to the unix socket via the write() function.
      const data = chunks.join('').slice(0, -1)
      const result = eval(data)
      socket.write(result)
      console.log('Request processed')
      socket.end()
    }
  })
})

// We open the unix socket, just like any other Node.js server. Via the listen() function.
// Unlike an express server, we don't pass a port. Rather we pass the path to the socket we decided on above.
server.listen(socketPath, () => {
  // The socket is now open.
  // The server we created is listening on it.
  console.log(`Server is listening at: ${socketPath}`)
})

process.on('SIGINT', () => {
  server.close()
  process.exit()
})
```

</Content>

<Content heading="Make it executable.">

This is an executable file. But, by default it's not executable until we set it's permissions. No problem, simply run the following.

```bash
# Sets the file permissions to be executable.

chmod +x ./bin/node
```

</Content>
</Box>

<Box heading="Connect to a Socket from PHP">

<Content>
  
Okay, great. See I told you this was simple.

Before we connect to the socket from PHP, we'll need to start up the Node.js server we just created.

Because it's an executable file, the command is super simple.

```bash
# Start the node.js server.

./bin/node
```

</Content>

<Content heading="Sending JavaScript to an Unix Socket from PHP">

There are so many cool things we can do here. I'm going to demonstrate how to server render a webpack bundle. And as a bonus I'll also demonstrate how to inject in some server side data such as the current route.

```php
<?php

namespace Acme;

use RuntimeException;
use Symfony\Component\Serializer\SerializerInterface;

use function fclose;
use function stream_get_contents;
use function stream_socket_client;
use function stream_socket_sendto;

class NodeRenderer {

  /**
  * Some server side data you'd like to inject.
  */
  private object $serverContext;

  /**
  * A serializer for converting the server context to json.
  */
  private SerializerInterface $serializer;

  /**
  * Path or url to an open socket.
  */
  private string $socketPath;

  /**
  * Path to your JavaScript bundle.
  */
  private string $bundlePath;

  public function __construct(
    SerializerInterface $serializer,
    string $socketPath,
    string $bundlePath,
    object $serverContext
  ) {
    $this->serializer = $serializer;
    $this->socketPath = $socketPath;
    $this->bundlePath = $bundlePath;
    $this->serverContext = $serverContext;
  }

  public function render(): string {

    // First we'll serialize the server side data that we're injecting into our JavaScript.
    $context = $this->serializer->serialize($this->serverContext, 'json');

    // This is the javascript you'd like eval'd.
    // It can be anything.
    // In this case we're going to pass our webpack bundle to Node.js to server render.
    // We can pass important data like the current route via the server context we pass in.
    // The possibilities are endless.
    $javascript  = <<<JS
      (function() {
        const Bundle = require($this->bundlePath);
        return Bundle($context);
      })();
    JS;

    // Next we connect to the open socket.
    $socket = stream_socket_client($this->socketPath, $errno, $errstr);
    if (!$socket) {
      throw new RuntimeException($this->socketPath . " does not reference an opened socket. Did you forget to start the Node.js server that opens the socket?");
    }

    // Here we pass the JavaScript to the socket.
    // Note the special token "\0". This is used by Node.js, to know theres no more js to wait on.
    stream_socket_sendto($socket, $javascript . "\0");

    // Annnnd.. we get the result back from le socket.
    $contents = stream_get_contents($socket);
    if ($contents === false) {
      throw new RuntimeException("Server blew up or something. Idk. Ask dev ops. It's their fault.");
    }

    fclose($sock);

    // And we return the contents to the caller.
    return $contents;
  }
}
```

</Content>

</Box>

<Box heading="Configuring your Webpack Bundle">

<Content heading="Seperate Server and Client bundles.">

If you're going to attempt to server render a webpack bundle, you'll want to create seperate server and client side bundles.

Here's a sample webpack configuration for a React app, written in TypeScript.

It will output the client side bundle to `public/build`, and the server side bundle to `var/node`.

As a bonus, install `run-node-webpack-plugin` to automatically start up your Node.js server, when bundling. [It has tons of customization options](https://www.npmjs.com/package/run-node-webpack-plugin).

Here I've configured the plugin to start the server only when running webpack in watch mode, and to restart the server upon re-bundle.

Another important detail is the server side bundles `output` configuration. If you noticed in the PHP script above, we required the server webpack bundle, and then called it as if it were a function. In order for this to be possible, the bundle must be output as a UMD bundle.

```js
const path = require('path')
const RunNodeWebpackPlugin = require('run-node-webpack-plugin')
const isEnvProduction = process.env.NODE_ENV === 'production'

module.exports = [
  {
    target: 'web',
    mode: isEnvProduction ? 'production' : 'development',
    devtool: isEnvProduction ? 'none' : 'inline-source-map',
    entry: {
      client: './src/Client.tsx'
    },
    output: {
      filename: 'client.[chunkhash].js',
      path: path.resolve('public/build'),
      clean: true
    },
    module: {
      rules: [
        {
          test: /\.(ts|js)x?$/,
          exclude: /node_modules/,
          use: {
            loader: 'babel-loader',
            options: {
              presets: [
                '@babel/preset-env',
                ['@babel/preset-react', { runtime: 'automatic' }],
                '@babel/preset-typescript'
              ]
            }
          }
        }
      ]
    },
    optimization: {
      minimize: isEnvProduction
    },
    plugins: [],
    resolve: {
      extensions: ['.tsx', '.ts', '.js', '.jsx', '.json']
    }
  },
  {
    target: 'node',
    mode: isEnvProduction ? 'production' : 'development',
    entry: {
      server: './src/Server.tsx'
    },
    output: {
      filename: 'bundle.js',
      path: path.resolve('var/node'),
      library: {
        name: 'Server',
        type: 'umd',
        export: 'default'
      }
    },
    module: {
      rules: [
        {
          test: /\.(ts|js)x?$/,
          exclude: /node_modules/,
          use: {
            loader: 'babel-loader',
            options: {
              presets: [
                '@babel/preset-env',
                ['@babel/preset-react', { runtime: 'automatic' }],
                '@babel/preset-typescript'
              ]
            }
          }
        }
      ]
    },
    plugins: [
      new RunNodeWebpackPlugin({
        scriptToRun: './bin/node',
        runOnlyOnChanges: false,
        runOnlyInWatchMode: true
      })
    ],
    resolve: {
      extensions: ['.tsx', '.ts', '.js', '.jsx', '.json']
    }
  }
]
```

</Content>

</Box>


Calling JavaScript code from PHP is suprisingly simple. You can render a react app server side, or call upon one of NPM's many libraries.

Server Render JavaScript from PHP via an Unix Socket


<Box heading="Create the `.certs/` Directory.">

<Content>

To get started we'll need a directory to store all of our certificates and private keys.

I have chosen a `~/.certs/` directory, but it can be whatever and wherever you want.

</Content>
<Content>

You can do this from the command line with the following.

```bash
# Create the ~/.certs directory.

$ mkdir ~/.certs
```

</Content>
</Box>

<Box heading="Generate and Trust the Root Private Key, and Certificate.">

<Content>
Now we’ll generate the root private key, and certifcate. Then you'll instruct your OS to trust this certificate.

</Content>

<Content heading="Trust is Key">

The secret to producing trusted self signed certificates, is configuring the operating system to to trust the certificate that signed it. As long as the signing certificate is trusted, any certificates it signs will also be trusted.

</Content>
<Content heading="Generate the Root Private Key">

First we'll need a private key. 2048 bits is perfect. Change the `-out` directory as needed.

```bash
# Generate a private key.

$ openssl genrsa \
  -out ~/.certs/root.key \
  2048
```

</Content>

<Content heading="Generate the Root Certificate">

Next, we'll generate a self signed certificate that will serve as our development certificate authority.

Again change the `-out` directory as needed.

```bash
# Generate a self signed certificate that will serve as the Certificate Authority.

$ openssl req \
  -x509 -new -nodes \
  -key ~/.certs/root.key \
  -sha256 \
  -days 1825 \
  -out ~/.certs/root.pem \
  -subj "/CN=Local CA"
```

</Content>

<Content heading="Configure Mac OS to trust the Certificate">

Now that we have our self signed certificate, lets tell Mac OS that it should be trusted.

```bash
# Tell Mac OS to add the certificate to it's keychain.

$ sudo security add-trusted-cert -d -r trustRoot -k "/Library/Keychains/System.keychain" ~/.certs/root.pem
```

</Content>
</Box>

<Box heading="Generate Self Signed Development Certificates">

<Content>

Great! Now, we’re ready to generate the self signed certificates for your development sites.

I like to place everything in a `~/.certs/` directory, however you may prefer to place the certificates with their associated projects. It's up to you.

</Content>

<Content heading="Generate Private Key for Development Domain">

First we'll create a new directory within `~/.certs/` for a hypothetical project called `test.local`. And then we create the private key.

You can do this is one step with the following.

```bash
# Creates a new directory, and a private key within it.

$ mkdir ~/.certs/test.local \
  && openssl genrsa -out ~/.certs/test.local/test.local.key 2048
```

</Content>

<Content heading="Generate a Code Signing Request">

You can think of a **Code Signing Request** as an order form that you send the root certificate. The root certificate recieves the code signing request and fulfills the order.

Note the `CN=test.local` part of the following command. CN stands for **Common Name** and its the url that you use to access your site. If it's localhost, be sure to add the port number.

```bash
# Create a Code Signing Request.

$ openssl req -new \
  -key ~/.certs/test.local/test.local.key \
  -out ~/.certs/test.local/test.local.csr \
  -subj "/CN=test.local"
```

</Content>
<Content heading="Generate Extension File">

A relatively recent requirement for SSL certificates is that they provide a **Subject Alternative Name**. Without one, Chrome will load the website, however it will display with the familiar red lock, and give an untrusted site warning.

No worries we can add the Subject Alternative Name to our Code Signing Request with an extension file.

```bash
# Create an extension file.

$ echo "\nDNS.1 = test.local" >> ~/.certs/test.local/.extfile
```

</Content>
<Content heading="Generate the self signed certificate">

Finally we can generate our trusted self signed certificate by sending our code signing request to the root certificate.

```bash
# Generate a trusted self signed certificate by sending a CSR to the trusted certificate.

$ openssl x509 -req \
  -in ~/.certs/test.local/test.local.csr \
  -CA ~/.certs/root.pem \
  -CAkey ~/.certs/root.key \
  -CAcreateserial \
  -out ~/.certs/test.local/test.local.crt \
  -days 365 \
  -sha256 \
  -extfile ~/.certs/test.local.extfile
```

</Content>
</Box>

<Box heading="Verify the Certificate is Trusted">

<Content>

To prove that the certificate is trusted, here's one last command.

```bash
# Verify the certificate is trusted.

$ openssl x509 -noout -text -in ~/.certs/test.local/test.local.crt
```

</Content>
</Box>

<Box heading="Command Reference">

<Content>

Heres a quick reference on all the commands I provided above.

```bash
# Generate a private key.
$ openssl genrsa -out example.org.key 2048*

# Generate an untrusted self signed certificate.
$ openssl req -x509 -new -nodes -key $PATH_TO_PRIVATE_KEY -sha256 -days 1825 -out $PATH_TO_SAVE_CERT -subj "/CN=Local CA"

# Tell Mac OS to trust a certificate to sign certificates.
$ sudo security add-trusted-cert -d -r trustRoot -k "/Library/Keychains/System.keychain" $PATH_TO_CERT

# Generate a Code Signing Request
$ openssl req -new -key $PATH_TO_PRIVATE_KEY -out $PATH_TO_SAVE_CSR -subj "/CN=$SITE_DOMAIN_NAME"

# Create a Code Signing Request extension to add a Subject Alternative Name.
$ echo "\nDNS.1 = $DOMAIN_NAME" >> $PATH_TO_SAVE_EXT_FILE

# Generate a Certificate from a Code Signing Request
$ openssl x509 -req -in $PATH_TO_CSR -CA $PATH_TO_ROOT_CERTIFICATE -CAkey $PATH_TO_ROOT_PRIVATE_KEY -CAcreateserial -out $PATH_TO_CREATE_CERTIFICATE -days 365 -sha256 -extfile $PATH_TO_EXTENSION_FILE
```

</Content>
</Box>


By properly creating a self signed certificate, we can get rid of the nagging browser errors for good.

Create Trusted Self Signed Certificates


<Box heading="How It's Done">
<Content heading="Introducing the PasswordHasher Component">

Utilizing the `UserPasswordHasher` from the new [Symfony PasswordHasher component](https://symfony.com/blog/new-in-symfony-5-3-passwordhasher-component), we can easily hash our Users password.

Typically we hash user passwords at the initial persist, and when passwords are modified. So, assuming those requirements, an efficient way to put this new component to work is in combination with a Doctrine Entity Listener.

</Content>
<Content heading="The Steps">

Theres 4 steps involved. 1st we'll need to create the `UserListener` class. This will be a Doctrine Entity Listener that listens for the persist and update Doctrine events on the User entity.

2nd, we'll need to tell Doctrine about this Listener, by tagging the class with `doctrine.orm.entity_listener`.

3rd, we'll need to configure the PasswordHasher within our security config.

And finnaly, we'll hook our User entity up by pointing to the new listener as the argument to a `Doctrine\ORM\Mapping\UserListener` annotation.

</Content>
<Content>

Let me show you how its done and how to wire it up in your config.

</Content>
</Box>

<Box heading="Creating the Doctrine Entity Listener">
<Content>

Take a look at the `UserListener` class below. I inject an instance of the `UserPasswordHasherInterface` in the constructor which allows it to be used within the private `encodePassword()` method.

The real work though, happens in the `prePersist()` and `preUpdate()` methods. These methods are called automatically by Doctrine when a user is being persisted, and being updated.

That being said, users are often updated for reasons besides changing their password. So within the `preUpdate()` method we must check if the users password has changed. If it was, then we hash and change it. Otherwise we can just return.

```php
// src/Doctrine/UserListener.php

namespace App\Doctrine;

use Doctrine\ORM\Mapping as Orm;
use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use App\Entity\User;

class UserListener {

  /** @var UserPasswordHasherInterface */
  private $hasher;

  /**
   * @param UserPasswordHasherInterface $encoder
   */
  public function __construct(UserPasswordHasherInterface $hasher) {
    $this->hasher = $hasher;
  }

  /** @Orm\PrePersist */
  public function prePersist(User $user, LifecycleEventArgs $args) {
    $password = $user->getPassword();
    $password = $this->encodePassword($user, $password);
    $user->setPassword($password);
  }

  /** @Orm\PreUpdate */
  public function preUpdate(User $user, PreUpdateEventArgs $args) {
    if ($args->hasChangedField('password')) {
      $password = $args->getNewValue('password');
      $password = $this->encodePassword($user, $password);
      $user->setPassword($password);
    }
  }

  private function encodePassword(User $user, string $password) {
    return $this->hasher->hashPassword($user, $password);
  }
}
```

</Content>
</Box>

<Box heading="Tag the Entity Listener">
<Content>

Within your `/config/services.yaml` you'll need to tell doctrine about the Entity Listener we just created. You do so by tagging the class with `doctrine.orm.entity_listener`.

</Content>
<Content heading="Tagging an Individual Class vs. an Entire Directory">

You can choose to either tag just the individual class, or tag the entire directory. If you plan on creating additional Doctrine Entity Listeners (and you probably will), then I recommend the latter. Otherwise you'll need to add service configuration for each class. Besides Doctrine Entity Listeners are so useful, you're bound to create more of them.

```yaml
# config/services.yaml

services:
  # ...

  # Tag just the UserListener:

  App\Doctrine\UserListener:
    tags: ['doctrine.orm.entity_listener']

  # OR tag an entire directory:

  App\Doctrine\:
    resource: '../src/Doctrine/'
    tags: ['doctrine.orm.entity_listener']
```

</Content>
</Box>

<Box heading="Configure the Symfony PasswordHasher component">
<Content>

Next up we'll need to configure the PasswordHasher. So while you're still in your config directory, open up `/config/packages/security.yaml` and add the following snippet.

</Content>
<Content heading="A Note On the Encoders Key">

Symfony has depricated much of the old security system, including the old password encoders. If you've already configured an `encoders` key, simply replace it with the following `password_hashers` key which is [intended to replace it](https://symfony.com/doc/6.0/security.html#c-hashing-passwords).

```yaml
# config/packages/security.yaml

security:
  # ...

  password_hashers:
    # use your user class name here
    App\Entity\User:
      algorithm: auto
```

</Content>
</Box>

<Box heading="Tell Doctrine which Entity to Listen On.">
<Content>

You've created an Entity Listener, told Doctrine about it, and configured password hashing.

The final step is to tell Doctrine which Entity to associate with the listener. In otherwords, which Entity should it listen for events on.

```php
// src/Entity/User.php

namespace App\Entity;

use Doctrine\ORM\Mapping as Orm;
use Symfony\Component\Security\Core\User\UserInterface;
use App\Doctrine\UserListener;

/**
 * A user entity.
 *
 * @Orm\Entity()
 * @Orm\EntityListeners({UserListener::class})
 */
class User extends BaseEntity implements UserInterface {

  //..

}
```

</Content>
<Content heading="Give it a Try">

And thats that. Go ahead and try persisting a new user. When you look at the result the password should be an unrecognizable mess of characters. If so, great job! If not, you may have missed a step, or misconfigured a small detail.

</Content>
</Box>
<Box heading="Learn More">
<Content>

If you'd like to learn more about Doctrine Entity Listeners, or the new Symfony PasswordHasher component, I encourage you to check out the following documentation.

[Symfony PasswordHasher Component](https://symfony.com/blog/new-in-symfony-5-3-passwordhasher-component)

[Doctrine ORM Entity Listeners](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/events.html#entity-listeners)

</Content>
<Content heading="The Interface of the PasswordHasherInterface">

Lastly, for reference, here is the interface of the `PasswordHasherInterface`.

```php
<?php

namespace Symfony\Component\PasswordHasher;

interface PasswordHasherInterface {

  public function hash(string $plainPassword): string;

  public function verify(string $hashedPassword, string $plainPassword): bool;

  public function needsRehash(string $hashedPassword): bool;

}
```

</Content>
</Box>


Implement automatic password encryption in Symfony using the new Symfony PasswordHasher component with Doctrine Entity Listeners.

Automatic Password Hashing in Symfony 5


<Box heading="The Doctrine Paginator">
<Content>

The Doctrine ORM makes paginating entities effortless with the Doctrine Paginator.

Below I've provided a simple Repository class for some generic Article entity. It contains a few examples for you to analyze, and I'll go over the 1st with you.

</Content>
<Content heading="The Doctrine Query Builder">

The following assumes knoledge of the Doctrine Query Builder. If you're unfamiliar with the Doctrine Query Builder, it's a topic for another post, but you can read all about it in the [Doctrine docs](https://www.doctrine-project.org/projects/doctrine-orm/en/2.9/reference/query-builder.html).

</Content>

</Box>

<Box heading="Get Paginated Posts">

<Content>

Take a look at the `getPaginatedPosts()` method below. It takes two arguments, a page number `$page`, and the number of posts per page `$postsPerPage`.

First we'll create a query using the Doctrine Query Builder. The line `$this->createQueryBuilder('a')->orderBy('a.timestamp', 'DESC')->getQuery()` creates a query of Article objects, sorted in descending order by a timestamp property.

Next we create an instance of the Doctrine Paginator, and pass it the query we just created.

Finnaly the line `$paginator->getQuery()->setFirstResult($postsPerPage * ($page - 1))->setMaxResults($postsPerPage)` is what actually does the pagination.

We get the query from the paginator object, and then set the 1st result to the product of `$postsPerPage * ($page - 1)`. This tells Doctrine Paginator to offset the results starting at a particular number. Finnaly we tell Doctrine the max amount of posts we want per page.

The result is the function returns the number of posts specified by `$postsPerPage` beginning from the result of `setFirstResult()`. Pretty simple huh?

```php
// src/Repository/ArticleRepository.php

namespace App\Repository;

use App\Entity\Article;
use Doctrine\ORM\Tools\Pagination\Paginator;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Symfony\Bridge\Doctrine\RegistryInterface;

class ArticleRepository extends ServiceEntityRepository {

  public function __construct(RegistryInterface $registry) {
    parent::__construct($registry, Article::class); }

  public function getPaginatedPosts($page = 1, $postsPerPage = 9) {
    $query = $this->createQueryBuilder('a')
      ->orderBy('a.publishedAt', 'DESC')
      ->getQuery();
    $paginator = new Paginator($query);
    $paginator->getQuery()
      ->setFirstResult($postsPerPage * ($page - 1))
      ->setMaxResults($postsPerPage);
    return $paginator;
  }

  /**
  * Assuming the associated Article entity has a many to one relationship to some Category entity.
  */
  public function getPaginatedPostsFromCategory($page = 1,  $postsPerPage = 9, $category) {
    $query = $this->createQueryBuilder('a')
      ->leftJoin('a.category', 'c')
      ->andWhere('c.slug = :val')
      ->setParameter('val', $category)
      ->orderBy('a.timestamp', 'DESC')
      ->getQuery();
    $paginator = new Paginator($query);
    $paginator->getQuery()
      ->setFirstResult($postsPerPage * ($page - 1))
      ->setMaxResults($postsPerPage);
    return $paginator;
  }

  /**
  * Assuming the associated Article entity has a many to many relationship to some Tags entity.
  */
  public function getPaginatedPostsFromTag($page = 1, $postsPerPage = 9, $tag) {
    $query = $this->createQueryBuilder('a')
      ->leftJoin('a.tags', 'c')
      ->andWhere('c.slug = :val')
      ->setParameter('val', $tag)
      ->orderBy('a.publishedAt', 'DESC')
      ->getQuery();
    $paginator = new Paginator($query);
    $paginator->getQuery()
      ->setFirstResult($limit * ($page - 1))
      ->setMaxResults($limit);
    return $paginator;
  }
}
```

</Content>

</Box>


Portfolio