DEV Community: Bryan Granado

Apigee Handbook on GCP: Quick Start Guide for starting

Bryan Granado — Wed, 10 Dec 2025 21:27:18 +0000

Has your DevOps or Platform Engineering team just handed you access to an Apigee organization in Google Cloud (GCP) and said, “You’re good to deploy your APIs”? If you opened the console and wondered where to start, this post is for you.

We’re not going to talk about VPC peering or instance provisioning (DevOps already handled that and it costs money). We’ll focus on what matters to you as a Developer: how to take that infrastructure “shell” and turn it into a secure, optimized, and functional gateway for your microservices.

1. High-level overview: where you stand

Apigee is an API Management platform. Think of it as an “Intelligent Receptionist” standing in front of your servers (the backend).

When DevOps configures the environment, they usually provide you with a default domain. Typically the invocation URL looks like:

https://{org-name}-{environment}.apigee.net

Or, if they set up a custom domain:
https://api.yourcompany.com

Your job is not to configure that domain; your job is to define what happens after the request reaches that URL.

2. What is an API Proxy?

The fundamental building block in Apigee is the API Proxy.

Think of it as a façade. The client (a mobile app, web app) never speaks directly to your backend (Cloud Run, GKE, VM). It speaks with the Proxy.

A Proxy lets you:

Decouple: Change your backend implementation (Java → Go, VM → Serverless) while keeping the public Proxy URL stable.
Secure: Validate tokens (OAuth, API Keys) before traffic reaches your backend.
Transform: Accept XML and return JSON without touching backend code.

3. Anatomy of a Proxy: Endpoint vs Target

This is where many get confused. A Proxy has two worlds:

A. Proxy Endpoint (the face to the client)

This defines how the outside world consumes your API. Here you define:

The Base Path (e.g., /v1/users).
Security rules (who can enter).
What happens before the request goes to the backend.

B. Target Endpoint (the connection to the backend)

This defines where Apigee fetches the data. Here you define:

The URL of your backend service.
SSL/TLS settings.
What happens when the backend responds.

Didactic note: The flow is:
Client -> Proxy Endpoint -> (logic) -> Target Endpoint -> Backend

4. Creating your first Proxy: Default vs Optimized

The “Default” way (Console UI)

For learning, the GCP Console is great.

Go to Apigee > Proxies > Create New.
Select Reverse Proxy.
Fill in:
- Name: user-service-v1
- Base Path: /v1/users
- Target (Backend): https://my-backend-on-cloudrun.app
Deploy. This generates a basic XML. It works, but for production you want more control.

The “Optimized” way (Development best practices)

A better professional approach is to avoid editing XML directly in the web console (it’s error-prone and hard to version). Instead, develop locally (VS Code + Apigee extension) and upload the bundle.
Because this post is for beginners, here’s a link that dives deeper:

docs

5. Environment variables: TargetServers and KVMs

This is where you collaborate with DevOps. Environments cost money; you don’t want a separate Proxy per environment.

A well-configured Target Endpoint should NOT hardcode a backend URL like this:

<HTTPTargetConnection>
    <URL>https://my-backend-dev.com</URL>
</HTTPTargetConnection>

What is a TargetServer?
A TargetServer is a named variable at environment level.

In DEV, the TargetServer named my-backend-server points to dev.backend.com (Cloud Run, VM, etc).

Your task: Ask DevOps to create the TargetServer for each environment (or create it yourself if you have permissions). Then reference the TargetServer by name in your XML.

6. Flows and Match Rules: the Proxy brain

A Proxy isn't an empty tube; it makes decisions. That’s implemented using Flows.

The execution flow inside an endpoint (Proxy or Target) follows this order:

PreFlow: Always runs. Put global logic here (e.g., traffic protection, API Key validation).

Conditional Flows: Run only if a condition (Match) applies.

PostFlow: Always runs at the end (e.g., transaction logging).

Configuring Conditional Flows with Matches

Suppose your API exposes:

GET /users (List)

POST /users (Create)

You might not want the same rules for both (POST may require stricter validation). Use <Condition>.

Example:

<Flow name="/CreateUser post">
  <Description>Logic for creating users</Description>
  <Condition>(proxy.pathsuffix MatchesPath "/users") and (request.verb = "POST")</Condition>

  <Request>
    <Step>
      <Name>Validate-JSON-Input</Name>
    </Step>
  </Request>
</Flow>

A more complete example:

<ProxyEndpoint name="default">
  <PreFlow name="PreFlow">
    <Request>
      <Step><Name>Verify-API-Key</Name></Step>
    </Request>
  </PreFlow>

  <Flow name="CreateResource">
    <Condition>(request.verb = "POST")</Condition>
    <Request>
      <Step><Name>Quota-Check</Name></Step>
    </Request>
  </Flow>

  <PostFlow name="PostFlow">
    <Response>
      <Step><Name>Remove-Internal-Headers</Name></Step>
    </Response>
  </PostFlow>
</ProxyEndpoint>

Context and flow variables

Apigee is “context aware”: everything passing through the proxy generates variables you can read in conditions:

request.header.Content-Type — to know the incoming payload type.
response.status.code — to detect backend failures.
developer.app.name — to identify the calling app.

This helps you implement defensive logic. If the backend returns 500, you don’t want to expose the backend stack trace; you can return a suitable response instead.

Example:

<Condition>
  (response.status.code = 500)
</Condition>

Policies

Policies are configurations that control parts of the flow. Apigee provides many built-in policies, and you configure them via XML and attach them to steps in flows.

Common policies:

Verify API Key:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<VerifyAPIKey async="false" continueOnError="false" enabled="true" name="Verify-API-Key-Policy">
  <APIKey ref="request.header.x-api-key"/>
</VerifyAPIKey>

OAuthV2 (Verify Access Token):

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<OAuthV2 async="false" continueOnError="false" enabled="true" name="Verify-OAuth-Token-Policy">
  <Operation>VerifyAccessToken</Operation>
  <AccessToken prefix="Bearer">request.header.Authorization</AccessToken>
</OAuthV2>

Access Control (IP-based filtering):

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<AccessControl async="false" continueOnError="false" enabled="true" name="Access-Control-Policy">
  <IPRules noRuleMatchAction="DENY">
    <Rule action="DENY" name="Block-Specific-IP">
      <SourceAddress mask="32">192.168.1.100</SourceAddress>
    </Rule>

    <Rule action="ALLOW" name="Allow-Internal-Network">
      <SourceAddress mask="24">10.0.0.0</SourceAddress>
    </Rule>
  </IPRules>

  <IPAddresses ref="client.ip"/>
</AccessControl>

if you need more help with this, here found:

Verify API Key:verify-key
OAuthV2: authV2
Access Control: access-control

Great — if you got this far you now have a rapid-start checklist and the basic concepts to manage APIs in your Apigee environment.

I hope this helps.

I’m on Threads, LinkedIn and Instagram as brngranado. See you there for more content.

How handler migrations in nestjs in an effective way using typeorm

Bryan Granado — Wed, 23 Apr 2025 03:25:12 +0000

Database migrations are an essential part of modern application development, allowing developers to manage changes to their database schema in a controlled and versioned manner. When building applications with NestJS and TypeORM, handling these migrations effectively is crucial for ensuring data integrity, enabling seamless collaboration among team members, and facilitating deployments across different environments. This guide will walk you through the process of setting up and managing database migrations in your NestJS project using TypeORM, focusing on best practices for a smooth development workflow.

Step 1: Download and Set Up NestJS
If you don't have the NestJS CLI installed globally, begin by installing it using npm or yarn:

npm install -g @nestjs/cli
# or
yarn global add @nestjs/cli

Once the CLI is installed, create a new NestJS project:

nest new project-name

Navigate into your newly created project directory:

cd project-name

Step 2: Install Dependencies for TypeORM with NestJS
You need to install the necessary packages to integrate TypeORM with your NestJS application, specifically for MySQL. This includes the @nestjs/typeorm package, typeorm itself, and the mysql2 database driver. We'll also keep reflect-metadata and typeorm-extension as they are generally useful.

npm install @nestjs/typeorm typeorm mysql2 reflect-metadata typeorm-extension
# or
yarn add @nestjs/typeorm typeorm mysql2 reflect-metadata typeorm-extension

Explanation of dependencies:

@nestjs/typeorm: Provides the NestJS module for integrating TypeORM.
typeorm: The core TypeORM library.
mysql2: The MySQL driver.
reflect-metadata: A required dependency for TypeORM to work with - TypeScript decorators.
typeorm-extension: Provides helpful utilities for TypeORM, including enhanced migration capabilities.

Step 3: Configure TypeORM in Your NestJS Application

Now that you have the dependencies installed, the next step is to configure the TypeOrmModule in your NestJS application. We'll create a dedicated data-source.ts file at the root of your project (or in a designated configuration directory) and define your TypeORM configuration there.
Create data-source.ts:
Create a file named data-source.ts in the root of your project directory and add the following content:

// data-source.ts
import { DataSource } from 'typeorm';
import { join } from 'path'; // Import join

export default new DataSource({
  type: 'mysql',
  host: 'localhost',
  port: 3306,
  username: 'root', // Your database username
  password: 'admin', // Your database password
  database: 'test', // Your database name
  entities: [
    // Specify the path to your entities relative to this file
    join(__dirname, '**/*.entity{.ts,.js}'),
  ],
  migrations: [
    // Specify the path to your migration files relative to this file
    join(__dirname, 'migrations/**/*{.ts,.js}'),
  ],
  migrationsRun: false,
  synchronize: true, // IMPORTANT: Set to false for production
});

Explanation of data-source.ts:

We import DataSourcefrom typeorm.
We create and export a new DataSource() instance with your MySQL connection details and paths to your entities and migrations.
The entitiesand migrationspaths are defined relative to the location of the data-source.ts file using join(__dirname, ...).
We set migrationsRun: false to prevent migrations from running automatically on application start.
Crucially, set synchronize: false for production environments. While synchronize: true can be convenient during initial development to quickly create tables based on your entities, it's dangerous in production as it can lead to data loss when schemas change. Migrations are the safe and controlled way to manage schema evolution in production.

Update AppModule:

Now, in your src/app.module.ts, you will import this dataSourceand use its options to configure the TypeOrmModule.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import dataSource from './data-source';
@Module({
  imports: [TypeOrmModule.forRoot({ ...dataSource.options })],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

By using ...dataSource.options, you are spreading the configuration defined in data-source.ts into the TypeOrmModule.forRoot() method. This ensures consistency between the configuration used by your NestJS application and the TypeORM CLI.

Now that your TypeORM configuration is set up using a separate data-source.ts file, you are ready to configure the TypeORM CLI and start creating your database migrations.

Step 4: Configurepackage.json Scripts for Migrations
To streamline the process of creating, generating, and running migrations, you should add scripts to your package.json file. These scripts will use the TypeORM CLI with the typeorm-ts-node-commonjs wrapper to execute commands directly on your TypeScript files, leveraging the data-source.tsconfiguration we created.

Open your package.json file and add the following scripts within the scripts block:

{
  "scripts": {
    "typeorm": "npx typeorm-ts-node-commonjs",
    "migration:create": "npm run typeorm migration:create ./src/migrations/%npm_config_name%",
    "migration:generate": "npm run typeorm migration:generate -d ./data-source.ts -n %npm_config_name%",
    "migration:run": "npm run typeorm migration:run -d ./data-source.ts",
    "migration:revert": "npm run typeorm migration:revert -d ./data-source.ts"
  },
  // ... other package.json configurations
}

Explanation of the Scripts:

"typeorm": "npx typeorm-ts-node-commonjs": This is a helper script that sets up the execution environment for TypeORM commands, allowing it to run TypeScript files directly. We use npx to execute the package binary without needing to install it globally.
"migration:create": "npm run typeorm migration:create ./src/migrations/%npm_config_name%": This script creates a new, empty migration file in the src/migrations directory. It uses %npm_config_name%to get the name you provide when running the command (e.g., npm run migration:create --name=CreateUsersTable).
"migration:generate": "npm run typeorm migration:generate -d ./data-source.ts -n %npm_config_name%": This script is more powerful. It generates a migration file by comparing your current database schema with your TypeORM entities. It figures out the necessary SQL commands (CREATE TABLE, ALTER TABLE, etc.) to make the database schema match your entities and writes them into a new migration file. It uses -d ./data-source.ts to specify the data source configuration and -n %npm_config_name% for the migration name.
"migration:run": "npm run typeorm migration:run -d ./data-source.ts": This script executes all pending migrations that have not yet been applied to the database specified in your data-source.ts.
"migration:revert": "npm run typeorm migration:revert -d ./data-source.ts": This script reverts the last applied migration. This is useful during development if you need to undo a recent schema change.

Difference between migration:createand migration:generate:

migration:create: Manual approach. Creates an empty migration file. You then manually write the up and downmethods with the SQL or TypeORM query builder commands to perform the desired schema changes.
migration:generate: Automatic approach. Compares entities to the database and automatically generates the SQL commands needed to synchronize the schema into the migration file's upand downmethods. You should always review the generated SQL to ensure it does exactly what you intend.

🚨 Environment Variable Syntax Alert (Windows vs. Linux/macOS) 🚨
The scripts provided above use%npm_config_name%, which is the syntax for accessing npm configuration variables (like the --name flag) on Windows.

If you are using Linux ** or **macOS, the syntax for accessing these variables is different. You should use $npm_config_name instead.

Here are the equivalent scripts for Linux / macOS:

{
  "scripts": {
    "typeorm": "npx typeorm-ts-node-commonjs",
    "migration:create": "npm run typeorm migration:create ./src/migrations/$npm_config_name",
    "migration:generate": "npm run typeorm migration:generate -d ./data-source.ts -n $npm_config_name",
    "migration:run": "npm run typeorm migration:run -d ./data-source.ts",
    "migration:revert": "npm run typeorm migration:revert -d ./data-source.ts"
  },
  // ... other package.json configurations
}

Make sure to use the script format that matches your operating system.

With these scripts configured, you can now easily manage your TypeORM migrations from your terminal using npm run <script-name>. The next step will cover how to create your first migration.

Step 5: Creating our first migration

Important: You must create a root project a folder with name "migrations", this will call when you runnig all your migrations

Now that yourpackage.json scripts are set up, you can create your first migration file. We'll use the migration:create script for this, which creates an empty migration file ready for you to define the schema changes manually.

Open your terminal in the project's root directory and run the following command, with a descriptive name for your migration:

npm run migration:create --name=CreateUsersTable
# or
yarn migration:create --name=CreateUsersTable

This command will create a new file in the src/migrations directory (as configured in your data-source.ts and package.json). The filename will typically follow the pattern <Timestamp>-<MigrationName>.ts. For example, 1745031524856-CreateUsersTable.ts.

Open this newly created file. You will find a class that implements the MigrationInterfacefrom TypeORM. This interface requires two methods: upand down.

The up method contains the logic to apply the schema changes (e.g., create tables, add columns).
The down method contains the logic to revert those changes (e.g., drop tables, remove columns). This is important for rolling back migrations if needed. Here's an example of what the generated file looks like, populated with the SQL to create a userstable as you provided:

import { MigrationInterface, QueryRunner } from 'typeorm';

export class CreateUsersTable1745031524856 implements MigrationInterface {

    // The 'up' method applies the migration
    public async up(queryRunner: QueryRunner): Promise<void> {
        // Use queryRunner.query to execute raw SQL commands
        await queryRunner.query(`
            CREATE TABLE users (
                id INT PRIMARY KEY AUTO_INCREMENT,
                name VARCHAR(255) NOT NULL,
                lastname VARCHAR(255) NOT NULL,
                email VARCHAR(255) UNIQUE NOT NULL,
                birth DATE NOT NULL,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            );
        `);
    }

    // The 'down' method reverts the migration
    public async down(queryRunner: QueryRunner): Promise<void> {
        // Use queryRunner.query to execute raw SQL commands to drop the table
        await queryRunner.query(`DROP TABLE IF EXISTS users`);
    }
}

In this example:

In the upmethod, we use queryRunner.query() to execute a raw SQL statement that creates a userstable with several columns, including id, name, lastname, email, birth, created_at, and updated_at. In the downmethod, we use queryRunner.query() to execute a raw SQL statement that drops the userstable if it exists.

When usingmigration:create, you are responsible for writing the SQL or using TypeORM's QueryRunner methods to define the schema changes precisely in both the upand downmethods. This gives you fine-grained control over your database schema evolution.

The next step will be to run this migration to apply the changes to your database.

Step 6: Running Your Migrations
Once you have created your migration file and defined the schema changes in the upmethod (and the corresponding rollback in the downmethod), you need to execute the migration to apply these changes to your database.

Use the following command in your terminal:

npm run migration:run
# or
yarn migration:run

What this command does:

Connects to the Database: The script uses the configuration defined in your data-source.ts file to establish a connection to your MySQL database.
Checks for Pending Migrations: TypeORM queries a special table (usually named typeorm_metadata) in your database to see which migrations have already been executed.
Executes Pending Migrations: It then runs the upmethod of any migration files that exist in your configured migrationsdirectory but have not yet been recorded as executed in the typeorm_metadatatable.
Records Executed Migrations: After successfully running a migration's upmethod, TypeORM records that migration in the typeorm_metadatatable, ensuring it won't be run again.

Keeping Track of Migrations:

TypeORM automatically manages the state of your migrations in the database. The typeorm_metadatatable stores the names of the migrations that have been applied, allowing TypeORM to know which migrations are pending.

Checking Migration Status (Optional but Recommended):

You can check the status of your migrations at any time using the TypeORM CLI. While we didn't explicitly add a script for this, you can run:

npm run typeorm migration:show -d ./data-source.ts
# or
yarn typeorm migration:show -d ./data-source.ts

This command will list all migrations and indicate whether they have been applied (X) or are pending ([ ]).

Reverting Migrations (for Development/Rollback):

As mentioned in Step 4, you can revert the last applied migration using:

npm run migration:revert
# or
yarn migration:revert

This executes the downmethod of the most recently applied migration and removes its entry from the typeorm_metadatatable. Use this cautiously, especially in environments with live data.

By following these steps, you can effectively manage your database schema changes in your NestJS application using TypeORM migrations. Remember to create a new migration file for every change to your database schema.

Wrap Up!
So, there you have it! Taming database changes in your NestJS app with TypeORM migrations isn't scary once you break it down. We got you hooked up with TypeORM, set up that cool data-source.ts file, dialed in some handy scripts in your package.json, and even cranked out and ran your very first migration.

Think of migrations as your database's personal diary – keeping track of every little change. It makes life way easier when you're working with a team or pushing updates live.

Seriously, get into the habit of using migrations for any database tweak. It's a game-changer for keeping things smooth and preventing headaches down the road.

Wanna keep up with more dev tips, tricks, and maybe some random tech thoughts? Hit me up on social media!

Threads: @brngranado
LinkedIn: @brngranado
Instagram: @brngranado
Swing by and say hi! And definitely stick around for the next blog post – got more cool stuff coming your way!

Laravel microservices with rabbitMQ and docker.

Bryan Granado — Sat, 15 Mar 2025 21:39:10 +0000

The proposal this post is understand how you make a simple microservices architecture, without all the drama that goes with it . We start with a point booster could be using for any context. Well, let do it

The first step were knows and is download a laravel repository, recommended from it's official page laravel official. Then will download docker(Im using docker desktop because is very easy for me) if you be using linux, must go to Docker official linux.

Once already with enviroment, were go to prepare our architecture! For this blog we are work with a restaurant request to cousine, thats basically through api-manager(client) we called all microservices that be cousine, grocery-store and recipes; this microservices will communicate among themselves and then return a response to api-manager, it handler all request from any client. Remember create a project(Microservice for each module)

Our architecture show like :

api-manager
cousine
grocery-store
recipes

The next step is download rabbitMq server, for communicate from local enviroment. You can get from or if you has downloaded docker(required) using:
docker run --name rabbitmq bitnami/rabbitmq:latest

Ok almost ready ... Once you get all prepared, its time of create our .yaml file for each project. Here leave how you must do it :

For api-manager and anothers services, we starting with create a docker-compose file with name:
docker-compose.yml
You show something like

Remember that it, must be in root of your service or microservice

Now, you must get a docker compose document as follows:

services:
  db:
    image: mysql:latest
    container_name: mysql
    ports:
      - "3306:3306"
    volumes:
      - mysql-volumes:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: laravel
    networks:
      - app-network

  laravel-app:
    build:
      context: ./docker/php
    container_name: laravel-app
    volumes:
      - .:/home/source/main
    working_dir: /home/source/main
    networks:
      - app-network

  nginx:
    build:
      context: ./docker/nginx
    container_name: todo-nginx
    ports:
      - "8000:80"
    depends_on:
      - laravel-app
    volumes:
      - .:/home/source/main
    networks:
      - app-network

volumes:
  mysql-volumes:
    driver: local
networks:
  app-network:
    driver: bridge
    name: app-network

Likewise for each services. Here :

Cousine

services:
  db:
    image: mysql:latest
    container_name: mysql-cousine
    ports:
      - "3307:3306"
    volumes:
      - mysql-volumes-cousine:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: laravel_cousine
    networks:
      - app-network

  laravel-app:
    build:
      context: ./docker/php
    container_name: micro-cousine
    volumes:
      - .:/home/source/main
    working_dir: /home/source/main
    networks:
      - app-network

  nginx:
    build:
      context: ./docker/nginx
    container_name: todo-nginx-cousine
    ports:
      - "8001:80"
    depends_on:
      - laravel-app
    volumes:
      - .:/home/source/main
    networks:
      - app-network

volumes:
  mysql-volumes-cousine:
    driver: local
networks:
  app-network:
    driver: bridge
    name: app-network

Recipes

services:
  db:
    image: mysql:latest
    container_name: mysql-recipes
    ports:
      - "3309:3306"
    volumes:
      - mysql-volumes-recipes:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: laravel_recipes
    networks:
      - app-network

  laravel-app:
    build:
      context: ./docker/php
    container_name: micro-recipes
    volumes:
      - .:/home/source/main
    working_dir: /home/source/main
    networks:
      - app-network

  nginx:
    build:
      context: ./docker/nginx
    container_name: todo-nginx-recipes
    ports:
      - "8003:80"
    depends_on:
      - laravel-app
    volumes:
      - .:/home/source/main
    networks:
      - app-network

volumes:
  mysql-volumes-recipes:
    driver: local
networks:
  app-network:
    driver: bridge
    name: app-network

Grocery store

services:
  db:
    image: mysql:latest
    container_name: mysql-grosery-store
    ports:
      - "3308:3306"
    volumes:
      - mysql-volumes-grosery-store:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: laravel_grocery
    networks:
      - app-network

  laravel-app:
    build:
      context: ./docker/php
    container_name: micro-grosery-store
    volumes:
      - .:/home/source/main
    working_dir: /home/source/main
    networks:
      - app-network

  nginx:
    build:
      context: ./docker/nginx
    container_name: todo-nginx-grosery-store
    ports:
      - "8002:80"
    depends_on:
      - laravel-app
    volumes:
      - .:/home/source/main
    networks:
      - app-network

volumes:
  mysql-volumes-grosery-store:
    driver: local
networks:
  app-network:
    driver: bridge
    name: app-network

Then for each services:
docker compose up

Remember that each microservice works with yours own databases settings, you must access to into console and set access for databases.

Important: You must set your databases into your container, allow grant access, create user etc.

In this part is moment lets to code and setting. In this case, api-manager handle all request from clients, then send this request to each microservice(cousine, grocery-store, recipes) some like this

<?php

namespace App\Http\Controllers;

use App\Jobs\Cousine\CreateCousineJob;
use App\Jobs\Cousine\DeleteCousineJob;
use App\Jobs\Cousine\FindOneCousineJob;
use App\Jobs\Cousine\GetCousineJob;
use App\Jobs\Cousine\UpdateCousineJob;
use App\Models\Cousine;
use App\Services\rabbitmq\ConsumeMQ;
use App\Services\rabbitmq\SendMQ;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;

class CousineController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $response = Http::get('http://nginx/api/cousine');
        if ($response->successful()) {
            return response()->json($response->json(), 200);
        } else {
            return response()->json(['error' => 'No se pudieron obtener los datos'], $response->status());
        }
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        SendMQ::handle('send_store_cousine_queue','send_store_cousine_exchange','cousine_key', $request->all());
        SendMQ::close();

        return response()->json(['message' => 'Mensaje enviado correctamente']);
    }

    /**
     * Display the specified resource.
     */
    public function show(string $id)
    {
        $response = Http::get('http://nginx/api/cousine/'.$id);
        if ($response->successful()) {
            return response()->json($response->json(), 200);
        } else {
            return response()->json(['error' => 'No se pudieron obtener los datos'], $response->status());
        }
    }




    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, string $id)
    {
        $payload = [
            'order_number' => $request->order_number,
            'status_id' => $request->status_id,
            'id' => $id
        ];

        // Despachar el job para actualizar una receta específica
        SendMQ::handle('send_update_cousine_queue','send_update_cousine_exchange','cousine_key_update', $payload);
        SendMQ::close();
    }

    public function updateWithIngredientsUpdated(Request $request, string $id)
    {
        $payload = [
            'order_number' => $request->order_number,
            'status_id' => $request->status_id,
            'recipe_id' => $request->recipe_id,
            'id' => $id
        ];

        // Despachar el job para actualizar una receta específica
        SendMQ::handle('send_update_cousine_ingredient_queue','send_update_cousine_ingredient_exchange','cousine_key_update_ingredient', $payload);
        SendMQ::close();
    }



    /**
     * Remove the specified resource from storage.
     */
    public function destroy(string $id)
    {
        DeleteCousineJob::dispatch($id);
        return response()->json(['message' => 'Cousine deleted'], 200);
    }
}

Yes I know ... You question is ¿Where I get the SendMQ class?
In this example, I wanna show, how can use strategies when using microservices, doesn't necessary that you implement everything with rabbitMQ or Kafka or sqs, events directs. You can combine depends of you needed. For this example, I was create a service folder and with 2 services : ConsumeMQ and SendMQ, each one handle they responsabilities. Here leave a code:
SendMQ:class

<?php

namespace App\Services\rabbitmq;

use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

class SendMQ
{
    protected static $connection;
    protected static $channel;

    /**
     * Establece la conexión a RabbitMQ y declara el canal de conexión.
     *
     * Si ya existe una conexión, no hace nada.
     *
     * @return void
     */
    protected static function connect()
    {
        if (is_null(self::$connection)) {
            self::$connection = new AMQPStreamConnection(
                env('AMQP_HOST', 'localhost'),
                env('AMQP_PORT', 5672),
                env('AMQP_USER', 'bryan'),
                env('AMQP_PASSWORD', '123456'),
                env('AMQP_VHOST', '/')
            );
            self::$channel = self::$connection->channel();
        }
    }

    /**
     * Envia un mensaje a la cola de mensajeria indicada.
     *
     * @param string $queueName   Nombre de la cola de mensajeria.
     * @param string $exchangeName Nombre de la exchange de mensajeria.
     * @param string $routingKey   Clave de routing para la cola especificada.
     * @param mixed  $data         Contenido del mensaje.
     */
    public static function handle($queueName, $exchangeName, $routingKey, $data)
    {
        self::connect();
        self::$channel->exchange_declare($exchangeName, 'direct', false, false, false);
        self::$channel->queue_declare($queueName, false, false, false, false);
        self::$channel->queue_bind($queueName, $exchangeName, $routingKey);
        $msg = new AMQPMessage(json_encode($data));
        self::$channel->basic_publish($msg, $exchangeName, $routingKey);
    }

    /**
     * Cierra la conexi n a RabbitMQ.
     *
     * Este m todo debe ser llamado cuando se haya terminado
     * de enviar mensajes y se desee liberar los recursos
     * relacionados con la conexi n.
     */
    public static function close()
    {
        if (self::$channel) {
            self::$channel->close();
        }
        if (self::$connection) {
            self::$connection->close();
        }
    }
}

ConsumeMQ

<?php

namespace App\Services\rabbitmq;

use App\Http\Controllers\CousineController;
use Illuminate\Support\Facades\Log;
use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

class ConsumeMQ
{
    protected static $connection;
    protected static $channel;
    protected static $receivedData = []; // Variable estática para almacenar datos

    protected static function connect()
    {
        if (is_null(self::$connection)) {
            self::$connection = new AMQPStreamConnection(
                env('AMQP_HOST', 'localhost'),
                env('AMQP_PORT', 5672),
                env('AMQP_USER', 'bryan'),
                env('AMQP_PASSWORD', '123456'),
                env('AMQP_VHOST', '/')
            );
            self::$channel = self::$connection->channel();
        }
    }

    public static function handle($queueName)
    {
        self::connect();

        // Declarar la cola
        self::$channel->queue_declare($queueName, false, false, false, false);

        // Callback para manejar los mensajes recibidos
        $msgCallback = function (AMQPMessage $msg) {
            Log::info(' [x] Recibiendo: ' . $msg->body);

            // Almacenar el mensaje recibido
            $list = json_decode($msg->body, true);
            CousineController::setDataList($list);
        };

        // Configurar el consumidor
        self::$channel->basic_consume($queueName, '', false, true, false, false, $msgCallback);

        // Mantener el consumidor activo hasta que se detenga
        echo " [*] Waiting for messages. To exit press CTRL+C\n";
        while (self::$channel->is_consuming()) {
            self::$channel->wait();
        }

        return self::$receivedData; // Retornar los datos recibidos
    }

    public static function getReceivedData()
{
    return self::$receivedData;
}

    public static function close()
    {
        if (self::$channel) {
            self::$channel->close();
        }
        if (self::$connection) {
            self::$connection->close();
        }
    }
}

then let to configure our exchange. On *config * folder you must create a file with a name that identify you connection with rabbitmq. For this case : amqp.php. The context is next


return [

    /*
    |--------------------------------------------------------------------------
    | Define which configuration should be used
    |--------------------------------------------------------------------------
    */

    'use' => env('AMQP_ENV', 'production'),

    /*
    |--------------------------------------------------------------------------
    | AMQP properties separated by key
    |--------------------------------------------------------------------------
    */

    'properties' => [

        'production' => [
            'host'                  => env('AMQP_HOST', 'localhost'),
            'port'                  => env('AMQP_PORT', 5672),
            'username'              => env('AMQP_USER', 'myuser'),
            'password'              => env('AMQP_PASSWORD', 'mypass'),
            'vhost'                 => env('AMQP_VHOST', '/'),
            'connect_options'       => [],
            'ssl_options'           => [],

            'exchange'              => 'amq.topic',
            'exchange_type'         => 'topic',
            'exchange_passive'      => false,
            'exchange_durable'      => true,
            'exchange_auto_delete'  => false,
            'exchange_internal'     => false,
            'exchange_nowait'       => false,
            'exchange_properties'   => [],

            'queue_force_declare'   => false,
            'queue_passive'         => false,
            'queue_durable'         => true,
            'queue_exclusive'       => false,
            'queue_auto_delete'     => false,
            'queue_nowait'          => false,
            'queue_properties'      => ['x-ha-policy' => ['S', 'all']],

            'consumer_tag'          => '',
            'consumer_no_local'     => false,
            'consumer_no_ack'       => false,
            'consumer_exclusive'    => false,
            'consumer_nowait'       => false,
            'consumer_properties'   => [],
            'timeout'               => 0,
            'persistent'            => false,
            'publish_timeout'       => 0, // Only applicable when a publish is marked as mandatory
            'qos'                   => false,
            'qos_prefetch_size'     => 0,
            'qos_prefetch_count'    => 1,
            'qos_a_global'          => false
        ],

    ],

];

With this, everything, we are already for work...

*I wait that being usefull for you .. remember leave you comment or ask. You always are welcome *

Fullcode link Here

Follow me : @brngranado at Instagram, X, LinkedIn, threads.

📫Create a email sender with nestjs and nodemailer

Bryan Granado — Wed, 13 Sep 2023 03:32:57 +0000

Intro ...🚀🚀🚀

Many times, implementing an email server can be exhausting, and time consuming, but we just want it fast and easy to implement. For these situations, Nestjs is the solution, and for me the practical way to implement any functionality.

The first step, that we must implement is to create a folder in our project: In my case I will give it a name "email-server", you can give it any name you want.

Then, once our folder is created, create 4 main files, a module, a service, a controller, and an interface.

We must remember if you use nestjs, use the line command stack provider, is a elegant shape, foment to good practices, also is quickly. 👀

After create our files, let to create 3 folders, that's using documents and images that wish use in you sender.

The entities folder representate all entities that use for get data and showing in you mail file
The Public we might use for save all attachment that use, like images or documents, whatever.
The templete folder, we'll use for save our html templete or ours multiples templete

Ready these, let to next step and these is download dependencies



    npm install --save @nestjs-modules/mailer nodemailer
    npm install --save pug

Important: I'm using pug, for someone unknow pug, is a Javascript library that was previously known as JADE. It is an easy-to-code template engine used to code HTML in a more readable fashion. One upside to PUG is that it equips developers to code reusable HTML documents by pulling data dynamically from the API More here : learn more about pug here. 👀

Now, generate the .env variables:



MAIL_HOST = "smtp.emailtest.com"
MAIL_PORT = 587
MAIL_USER = "myuser"
MAIL_PASS = "mypass"

Now, navigate to app.module.ts that's root of our applicatiopn a paste the next code:




  import { MailerModule } from '@nestjs-modules/mailer';
  import { PugAdapter } from '@nestjs-modules/mailer/dist/adapters/pug.adapter';

   MailerModule.forRoot({
      transport: {
        host: String(process.env.MAIL_HOST),
        port: Number(process.env.MAIL_PORT),
        secure: false,
        auth: {
          user: process.env.MAIL_USER,
          pass: process.env.MAIL_PASS,
        },
      },
      template: {
        dir: __dirname + './template/notification',
        adapter: new PugAdapter({  inlineCssEnabled: true,}),
        options: {
          strict: true,
        },
      },
    }),

Now, got this, lets to folder where is our email server, in my case email-server and go to email-server.interface and create a file like this:



export interface MailService {

    /**
     * @description Send email
     */
    sendMail(content: Object): Promise<void>;

    /**
     * @description Send email sandbox
     */
    sendMailSandBox(content: Object): Promise<void>;
}

We can use this, also to add another type functions or attributes that handle standard for integration or multiple uses cases in your classes. Once done, let to create our controller, controller will be only for test, already that process to send message notification via email, will be implement in others functions into your app.



import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { EmailServerService } from './email-server.service';
import { CreateEmailServerDto } from './dto/create-email-server.dto';

@Controller('api/email-server')
export class EmailServerController {
  constructor(private readonly emailServerService: EmailServerService) {}

  @Post('test')
  testEMail(@Body() createEmailServerDto: CreateEmailServerDto) {
    return this.emailServerService.sendMailSandBox(createEmailServerDto);
  }
}

Important: The sandbox function allowed test our mail service with local behavior, I dont recomended for use in production server, alright might cause confuse to users. 👀

Once did say it, let's with our service.



import { Injectable, StreamableFile } from '@nestjs/common';
import { CreateEmailServerDto } from './dto/create-email-server.dto';
import { UpdateEmailServerDto } from './dto/update-email-server.dto';
import { MailService } from './email-server.interface';
import { MailerService as MailerMain } from '@nestjs-modules/mailer';
import { createReadStream, readFileSync} from 'fs';
import { join } from 'path';
import * as path from 'path';
import * as pug from 'pug';

@Injectable()
export class EmailServerService implements MailService{
 constructor(private readonly mailerMain: MailerMain) {}

 /**
 * Sends an email using the provided data.
 *
 * @param {object} datamailer - The data for the email.
 * @param {string} datamailer.templete - The template for the email body.
 * @param {object} datamailer.dataTemplete - The data to be used in the email template.
 * @param {string} datamailer.to - The recipient of the email.
 * @param {string} datamailer.subject - The subject of the email.
 * @param {string} datamailer.text - The plain text version of the email body.
 * @return {Promise<void>} A promise that resolves when the email is sent.
 */
 async sendMail(datamailer): Promise<void> {
     const render = this._bodytemplete(datamailer.templete, datamailer.dataTemplete);
    await this._processSendEmail(datamailer.to, datamailer.subject, datamailer.text, render);
 }

/**
 * Sends an email using the provided email server.
 *
 * @param {CreateEmailServerDto} email - The email object containing the recipient, subject, and text.
 * @return {Promise<void>} - A promise that resolves when the email is sent successfully.
 */
 async sendMailSandBox(email: CreateEmailServerDto): Promise<void> {
    const templateFile = path.join(__dirname, '../../src/email-server/templete/notification.pug'); 
    const fileImg = path.join(__dirname, '../../src/email-server/public/img/amico.png'); 
    const socialMediaImg = path.join(__dirname, '../../src/email-server/public/img/social-media.png'); 
    const imageData = readFileSync(fileImg).toString('base64'); 
    const imageDataSocialMedia = readFileSync(socialMediaImg).toString('base64'); 

    const data = {
      title: 'My title',
      img: imageData,
      myDescription: 'description',
      imgSocial: imageDataSocialMedia,
    };

    const render = this._bodytemplete(templateFile, data);
    await this._processSendEmail(email.to, email.subject, email.text, render);
 }

/**
 * Generate the function comment for the given function body.
 *
 * @param {string} templete - The path to the template file.
 * @param {Object} data - The data object to be passed to the template.
 * @return {string} The rendered template.
 */
 _bodytemplete(templete, data) {
  return  pug.renderFile(templete, { data });
 }

/**
 * Sends an email with the specified details.
 *
 * @param {string} to - The recipient of the email.
 * @param {string} subject - The subject of the email.
 * @param {string} text - The plain text content of the email.
 * @param {string} body - The HTML content of the email.
 * @return {Promise<void>} A promise that resolves when the email is sent successfully.
 */
 async _processSendEmail(to, subject, text, body): Promise<void> {
   await  this.mailerMain.sendMail({
        to: to,
        subject: subject ,
        text: text,
        html: body,
      })
      .then(() => {
        console.log('Email sent');
      })
      .catch((e) => {
        console.log('Error sending email', e);
      });
  }

}

Now, we'll create our module



import { Module } from '@nestjs/common';
import { EmailServerService } from './email-server.service';
import { EmailServerController } from './email-server.controller';
import { MailerModule } from '@nestjs-modules/mailer';
import { PugAdapter } from '@nestjs-modules/mailer/dist/adapters/pug.adapter';


@Module({
  controllers: [EmailServerController],
  providers: [EmailServerService],
  exports: [EmailServerService],
})
export class EmailServerModule {}

Then and the last, we create our templete




<!DOCTYPE html>
<html lang="en">
<head>
    <link href="https://fonts.googleapis.com/css?family=Gotham:400,500,700" rel="stylesheet">
</head>
<body style="font-family:'Gotham', sans-serif;">
    <div class="container" style="width: 500px; margin: 70px auto 0; text-align: center;">
        <div class="image">
            <img src="data:image/png;base64,${data.img}" alt="cuarentena-img" style="width: 200px; height: 200px;">
        </div>
        <h2 style="text-align: center; font-weight: 600;">${data.title}</h2>
        <div class="text" style="text-align: justify;">
            <p style="margin-top: 10px; margin-bottom: 10px; color: #41404699; font-size: 16px; font-weight: 400;">Regards!</p>
            <p style="color: #41404699; font-size: 16px; font-weight: 400;">${data.description}</p>
            <hr style="border: 1px solid #ccc; color: #41404626; margin-top: 70px; margin-bottom: 20px;">
        </div>
        <div class="image">
            <img src="data:image/png;base64,${data.imgSocial}" alt="social-media-img">
        </div>
        <div class="copyright" style="text-align: center; font-size: 0.8em; font-weight: 600;">
            <p style="margin-top: 30px; margin-bottom: 10px; color: #41404699;">My App ${data.year} ©. All rights reserved.</p>
        </div>
    </div>
</body>
</html>

Remember: Add the extension .pug into your file. 👀

DONE 🦾🦾🦾🎉🎉🎉

Thanks for come to here... follow me and comment, Im stay pending your ask and like it... See you there, in another article!

More info:
➡ nestjs-mailer
➡ nestjs.

🤖 My Github: @brngranado

How to implement authentication with nestjs using guards in 3 easy steps

Bryan Granado — Tue, 14 Feb 2023 02:51:36 +0000

Currently many companies has change the perspective to do a application, many frameworks and libraries up at date, was changed the developement form and them implementation themselves has doing that exist solutions to problem reallity complex. Today, we tell a litte bit about nestjs, that's a framework progressive for backend with javascript, through which can create scalables applications of a clean mode and ordered.

So, but, ¿Wich topics we'll talk? , Let' s talking about Guards in Nestjs, a tools multidiciplinary, that allow implement anything logic before of a request arrive ours controllers.

The official concepts is a class annotated with the @Injectable() decorator, which implements the CanActivate interfaceGuard have a single responsibility. They determine whether a given request will be handled by the route handler or not, depending on certain conditions (like permissions, roles, ACLs, etc.) present at run-time. This is often referred to as authorization. Authorization (and its cousin, authentication, with which it usually collaborates) has typically been handled by middleware in traditional Express applications. Middleware is a fine choice for authentication, since things like token validation and attaching properties to the request object are not strongly connected with a particular route context (and its metadata).

In this blog do not talk about all that can do with this functionality, specifycly look how implements a guard for authentication without install nothing and easy form. Let's go

Zero step:

We must have a create a Nestjs project at our computers, for to do this, review , important too, you has must create a module, with any functionality, else you must create a module with:

npm g module Foo

And complete step with next and done !

First step:

The first that we'll must do is create a guard, for this we use the command:

nest generate gu FooGuard

This command, will create something like this:

import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class FooGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    return true;
  }
}

We remember, that this Guard implements a interface CanActivate, that is who management all logic of our guard.

Ok, after let's create own decorator, is very important, because this will call by dependency injection, into our guard

import { SetMetadata } from '@nestjs/common';
import { FooEnum } from './FooEnum.enum';

export const FooRolesDecorator = (...fooRolesDecorator: FooRolesDecorator[]) =>
  SetMetadata('fooRolesDecorator', FooEnum);

**Important: **Is'nt necesary create a Enum, but is very recommended by nestjs, for best practices, more info: https://docs.nestjs.com/openapi/types-and-parameters#enums

Second step:

Once created a guard file and his decorator, let's to implementation, for this is very important that you have knowledge about drive the dependency injection. For drive ecosistems with dependy injection, nestjs, provide a interface al ready to use, ExecutionContext, that basically is do that to describing details about the current request pipeline and return two methods, getClass(), that returns the type of the controller class which the current handler belongs to, and getHandler() that returns a reference to the handler (method) that will be invoked next in the
request pipeline. For morte info: https://docs.nestjs.com/guards#execution-context

So, after understand this concept, use this class, is to take a parameter, that will be, our role.

@Injectable()
export class FooGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    @Inject('MY_REPO_IN_MODULE')
    private myRepoInModule: Repository<MiModel>,
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const role = this.reflector.getAllAndOverride<
      FooRolesDecorator[]
    >('fooRolesDecorator ', [context.getHandler(), context.getClass()]);

    if (!role ) {
      return false;
    }

    const request = context.switchToHttp().getRequest();
    const user = request.headers['user-id'];


    if (!user) {
      throw new HttpException(
        {
          status: 403,
          error: `Do not have authorization`,
        },
        403,
      );
    }

    const roleUser = await this.myRepoInModule.findOne({
      where: {user_id: user.userId});

    if (!reqUser) {
      throw new HttpException(
        {
          status: 403,
          error: `Do not have authorization`,
        },
        403,
      );
    }
  }
    return true;
  }
}

HINT: The Reflector helper is using for retrieve metadata for a specified key for a specified target. A little words, get data that set into our Decorator.
HINT: The method, getRequest() to allow, obtain object request, from the context.
HINT: The Guards take the (Repositories, entities) from modules where these was called, of automatically.

Third step:

In this last step, to implement into anything controller(preferly), into you application.

@Controller('api/foo')
@UseGuards(FooGuard)
export class RolesController {
  constructor(private readonly rolesService: RolesService) {}

  @Get()
  @FooRolesDecorator(MyEnum.Admin || 'Admin')
  create(@Body() createRoleDto: CreateRoleDto) {
    return this.rolesService.create(createRoleDto);
  }
}

HINT: The @UseGuards() Decorator that binds guards to the scope of the controller or method, depending on its context. When @UseGuards is used at the controller level, the guard will be applied to every handler (method) in the controller.
HINT: The decorator, @FooRolesDecorator() allow through dependency injection, set to parameter, for validate his needed's authorization.

Done!!

A Guard with nest a 3 easy steps ...

Don't forget follow in my social media:

@brngranado at instagram
@brngranado at twitter
@GranadoLab at Github

See you there !

How to create an app using laravel with inertiajs and react 2022

Bryan Granado — Tue, 15 Feb 2022 16:11:28 +0000

Many applications in the present, using by rule a separate schema of front and back. It's cool, but ¿What happens if need an app in a short time? May this be boring or exhausting, will create API, later the app in the frontend.
For this, laravel was incorporated many tools that allow creating a spa with technologies frontend like(vue, react,svelte). This blog tells how to do this with inertia.js.

The first to do is download laravel and all dependencies, as we already know. Later proceed to setup up inertiajs.

Installation

Server side

Once downloaded laravel with all dependencies, we go to the terminal in our project and we place:

composer require inertiajs/inertia-laravel

Once downloaded all dependencies of inertia, but server side. Now, we go to a create our file app.blade.php in resources/views/




<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0" />
    <link href="{{ mix('/css/app.css') }}" rel="stylesheet" />
    <script src="{{ mix('/js/app.js') }}" defer></script>
    @inertiaHead
  </head>
  <body>
    @inertia
  </body>
</html>

IMPORTANT: By default the Laravel adapter will use the app.blade.php view. This template should include your assets, as well as the @inertia directive. If you'd like to use a different root view, you can change it using Inertia::setRootView().

Next, setup the Inertia middleware. In Laravel you need to publish the HandleInertiaRequests middleware to your application, which can be done using this artisan command:

php artisan inertia:middleware

Once generated, register the HandleInertiaRequests middleware in your App\Http\Kernel, as the last item in your web middleware group.



'web' => [
    // ...
    \App\Http\Middleware\HandleInertiaRequests::class,
],

Client side

Now, we go install all dependencies, but the client-side. This can to done using yarn or npm, the one you like, in the terminal, will write:



npm install @inertiajs/inertia @inertiajs/inertia-react
yarn add @inertiajs/inertia @inertiajs/inertia-react

Later will initialize app, we go to routes file resources/js/app.js and update the file and will insert the code to below

IMPORTANT: *No delete nothing, only update! *



import React from 'react'
import { render } from 'react-dom'
import { createInertiaApp } from '@inertiajs/inertia-react'

createInertiaApp({
  resolve: name => require(`./Pages/${name}`),
  setup({ el, App, props }) {
    render(<App {...props} />, el)
  },
})

Next, will we go create a folder within name *Pages * in our route files resources/js. Here, save all pages and subpages(components) of react. Example:

Optional can do install a progress indicator, this will allow to see a loaded or refresh page progress with color in the top page.
To use it, start by installing it:



npm install @inertiajs/progress
yarn add @inertiajs/progress

Once it's been installed, initialize it in your app. Too in the file route resources/js/app.js:



import { InertiaProgress } from '@inertiajs/progress'

InertiaProgress.init()

To use code splitting with Inertia you'll need to enable dynamic imports. You'll need a Babel plugin to make this work. First, install the plugin:



npm install @babel/plugin-syntax-dynamic-import
yarn add @babel/plugin-syntax-dynamic-import

Next, create a .babelrc file in your project root laravel and insert this code:



{
  "plugins": ["@babel/plugin-syntax-dynamic-import"]
}

IMPORTANT: If you're using Laravel Mix, the dynamic imports Babel plugin is already configured. However, we recommend using Laravel Mix 6, as there are known issues with older versions.

And Done!

You can start will build amazing things, with reactive tecnologies.

For more information remember check :
Laravel
Inertiajs
reactjs

How do used transform in Laravel

Bryan Granado — Thu, 10 Feb 2022 18:07:51 +0000

Build an API sometimes may usually be exhausting, over all, if it was existing changes continuous in databases. Is very common created a class and this class pass him parameter, in small applications this frequently easy, but in a big application, ¿how resolved this?. The response is transform.

Default Laravel provides a class in his dependencies, that allow to create each model his respective manipulation information.

This class will we can found in the file app/vendor/league/fractal/src/TransformerAbstract, This is an abstract class which will intercept each one of our models.

<?php

/*
 * This file is part of the League\Fractal package.
 *
 * (c) Phil Sturgeon <me@philsturgeon.uk>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace League\Fractal;

use League\Fractal\Resource\Collection;
use League\Fractal\Resource\Item;
use League\Fractal\Resource\NullResource;
use League\Fractal\Resource\Primitive;
use League\Fractal\Resource\ResourceInterface;

/**
 * Transformer Abstract
 *
 * All Transformer classes should extend this to utilize the convenience methods
 * collection() and item(), and make the self::$availableIncludes property available.
 * Extend it and add a `transform()` method to transform any default or included data
 * into a basic array.
 */
abstract class TransformerAbstract
{
    /**
     * Resources that can be included if requested.
     *
     * @var array
     */
    protected $availableIncludes = [];

    /**
     * Include resources without needing it to be requested.
     *
     * @var array
     */
    protected $defaultIncludes = [];

    /**
     * The transformer should know about the current scope, so we can fetch relevant params.
     *
     * @var Scope
     */
    protected $currentScope;

    /**
     * Getter for availableIncludes.
     *
     * @return array
     */
    public function getAvailableIncludes()
    {
        return $this->availableIncludes;
    }

    /**
     * Getter for defaultIncludes.
     *
     * @return array
     */
    public function getDefaultIncludes()
    {
        return $this->defaultIncludes;
    }

    /**
     * Getter for currentScope.
     *
     * @return \League\Fractal\Scope
     */
    public function getCurrentScope()
    {
        return $this->currentScope;
    }

    /**
     * Figure out which includes we need.
     *
     * @internal
     *
     * @param Scope $scope
     *
     * @return array
     */
    private function figureOutWhichIncludes(Scope $scope)
    {
        $includes = $this->getDefaultIncludes();

        foreach ($this->getAvailableIncludes() as $include) {
            if ($scope->isRequested($include)) {
                $includes[] = $include;
            }
        }

        foreach ($includes as $include) {
            if ($scope->isExcluded($include)) {
                $includes = array_diff($includes, [$include]);
            }
        }

        return $includes;
    }

    /**
     * This method is fired to loop through available includes, see if any of
     * them are requested and permitted for this scope.
     *
     * @internal
     *
     * @param Scope $scope
     * @param mixed $data
     *
     * @return array
     */
    public function processIncludedResources(Scope $scope, $data)
    {
        $includedData = [];

        $includes = $this->figureOutWhichIncludes($scope);

        foreach ($includes as $include) {
            $includedData = $this->includeResourceIfAvailable(
                $scope,
                $data,
                $includedData,
                $include
            );
        }

        return $includedData === [] ? false : $includedData;
    }

    /**
     * Include a resource only if it is available on the method.
     *
     * @internal
     *
     * @param Scope  $scope
     * @param mixed  $data
     * @param array  $includedData
     * @param string $include
     *
     * @return array
     */
    private function includeResourceIfAvailable(
        Scope $scope,
        $data,
        $includedData,
        $include
    ) {
        if ($resource = $this->callIncludeMethod($scope, $include, $data)) {
            $childScope = $scope->embedChildScope($include, $resource);

            if ($childScope->getResource() instanceof Primitive) {
                $includedData[$include] = $childScope->transformPrimitiveResource();
            } else {
                $includedData[$include] = $childScope->toArray();
            }
        }

        return $includedData;
    }

    /**
     * Call Include Method.
     *
     * @internal
     *
     * @param Scope  $scope
     * @param string $includeName
     * @param mixed  $data
     *
     * @throws \Exception
     *
     * @return \League\Fractal\Resource\ResourceInterface
     */
    protected function callIncludeMethod(Scope $scope, $includeName, $data)
    {
        $scopeIdentifier = $scope->getIdentifier($includeName);
        $params = $scope->getManager()->getIncludeParams($scopeIdentifier);

        // Check if the method name actually exists
        $methodName = 'include'.str_replace(' ', '', ucwords(str_replace('_', ' ', str_replace('-', ' ', $includeName))));

        $resource = call_user_func([$this, $methodName], $data, $params);

        if ($resource === null) {
            return false;
        }

        if (! $resource instanceof ResourceInterface) {
            throw new \Exception(sprintf(
                'Invalid return value from %s::%s(). Expected %s, received %s.',
                __CLASS__,
                $methodName,
                'League\Fractal\Resource\ResourceInterface',
                is_object($resource) ? get_class($resource) : gettype($resource)
            ));
        }

        return $resource;
    }

    /**
     * Setter for availableIncludes.
     *
     * @param array $availableIncludes
     *
     * @return $this
     */
    public function setAvailableIncludes($availableIncludes)
    {
        $this->availableIncludes = $availableIncludes;

        return $this;
    }

    /**
     * Setter for defaultIncludes.
     *
     * @param array $defaultIncludes
     *
     * @return $this
     */
    public function setDefaultIncludes($defaultIncludes)
    {
        $this->defaultIncludes = $defaultIncludes;

        return $this;
    }

    /**
     * Setter for currentScope.
     *
     * @param Scope $currentScope
     *
     * @return $this
     */
    public function setCurrentScope($currentScope)
    {
        $this->currentScope = $currentScope;

        return $this;
    }

    /**
     * Create a new primitive resource object.
     *
     * @param mixed                        $data
     * @param callable|null                $transformer
     * @param string                       $resourceKey
     *
     * @return Primitive
     */
    protected function primitive($data, $transformer = null, $resourceKey = null)
    {
        return new Primitive($data, $transformer, $resourceKey);
    }

    /**
     * Create a new item resource object.
     *
     * @param mixed                        $data
     * @param TransformerAbstract|callable $transformer
     * @param string                       $resourceKey
     *
     * @return Item
     */
    protected function item($data, $transformer, $resourceKey = null)
    {
        return new Item($data, $transformer, $resourceKey);
    }

    /**
     * Create a new collection resource object.
     *
     * @param mixed                        $data
     * @param TransformerAbstract|callable $transformer
     * @param string                       $resourceKey
     *
     * @return Collection
     */
    protected function collection($data, $transformer, $resourceKey = null)
    {
        return new Collection($data, $transformer, $resourceKey);
    }

    /**
     * Create a new null resource object.
     *
     * @return NullResource
     */
    protected function null()
    {
        return new NullResource();
    }
}

¿So, how uses that? Sample, first we go to the console, we will write the next command: php artisan:make transformer. Automatically, Laravel will has created for our a class with all necessary an used.

php artisan make:transformer MyFolder(optional)/MyTransformer

Then will we go to our model that we want to apply a transform:

In we model instancing a property public
that property will equal to instance of our transformer
Working in the necessary in our model (queries, relationships, anyway)
we are ready

<?php

namespace App\Models;

use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Model;
use Silber\Bouncer\Database\Role as BounceRole;
use App\Transformers\RoleTransformer;

class Role extends BounceRole
{
    const TYPE_ADMIN = 'admin';
    const TYPE_USER = 'user';

    public $transformer = RoleTransformer::class;

    protected $table = 'participant.roles';

    protected $fillable = [
        'name',
        'title',
        'type',
        'user_limit',
    ];


}

Now will we go to file transform, previously created. Once there, import our model and do we next.

We pass our model to the transform method.
Instantiate other models and relationships you have associated with your model.
-Build a solid data structure consistent for your users, and that do not require changes.

<?php

namespace App\Transformers;

use App\Models\Role;
use League\Fractal\TransformerAbstract;

class RoleTransformer extends TransformerAbstract
{
    /**
     * List of resources to automatically include
     *
     * @var array
     */
    protected $defaultIncludes = [
        //
    ];

    /**
     * List of resources possible to include
     *
     * @var array
     */
    protected $availableIncludes = [
        //
    ];

    /**
     * A Fractal transformer.
     *
     * @return array
     */
    public function transform(Role $role)
    {
        $abilities = $role->getAbilities()->map(function ($ability) {
            return $ability->only(['id', 'name', 'title']);
        });

        return $role->only('id', 'name', 'title', 'type') + [ 'userLimit' => $role->user_limit, 'abilities' => $abilities ];
    }
}

And Done !!! your structure should look something like this:

{
    "status": 200,
    "content": [
        {
            "id": 7,
            "codRole": "DIR",
            "nbName": "Director",
            "createdAt": "2022-0120T15:57:34.000000Z",
            "updatedAt": "2022-0120T15:57:34.000000Z",
            "estatus": {
                "id": 1,
                "code": "AR",
                "name": "ACTIVE"
            }
}