README

Rzl Ziggy – Use your Laravel routes in JavaScript (Customize).

Rzl Ziggy – provides a JavaScript route() function that works like Laravel's, making it a breeze to use your named Laravel routes in JavaScript, with customize extra attribute and configs stub file.

Installation
Usage
JavaScript frameworks
Filtering Routes
- Including/excluding routes
- Filtering with groups
Other
Contributing

Installation

Install Rzl Ziggy in your Laravel app with Composer:

composer require rzl-app/ziggy

Install Rzl Ziggy in your code base Front-end or SPA with NPM:

npm i rzl-app-ziggy

Add the @rzlRoutes Blade directive to your main layout (before your application's JavaScript), and the route() helper function will be available globally!

By default, the output of the @rzlRoutes Blade directive includes a list of all your application's routes and their parameters. This route list is included in the HTML of the page and can be viewed by end users. To configure which routes are included in this list, or to show and hide different routes on different pages, see Filtering Routes.

Usage

`route()` function

Rzl Ziggy's route() function works like Laravel's route() helper—you can pass it the name of a route, and the parameters you want to pass to the route, and it will generate a URL.

Basic usage

Route::get('posts', fn (Request $request) => /* ... */)->name('posts.index');

route('posts.index'); // 'https://ziggy.test/posts'

Parameters

Route::get('posts/{post}', fn (Post $post) => /* ... */)->name('posts.show');

route('posts.show', 1);           // 'https://ziggy.test/posts/1'
route('posts.show', [1]);         // 'https://ziggy.test/posts/1'
route('posts.show', { post: 1 }); // 'https://ziggy.test/posts/1'

Multiple parameters

Route::get('venues/{venue}/events/{event}', fn (Venue $venue, Event $event) => /* ... */)
    ->name('venues.events.show');

route('venues.events.show', [1, 2]);                 // 'https://ziggy.test/venues/1/events/2'
route('venues.events.show', { venue: 1, event: 2 }); // 'https://ziggy.test/venues/1/events/2'

Query parameters

Rzl Ziggy adds arguments that don't match any named route parameters as query parameters:

Route::get('venues/{venue}/events/{event}', fn (Venue $venue, Event $event) => /* ... */)
    ->name('venues.events.show');

route('venues.events.show', {
    venue: 1,
    event: 2,
    page: 5,
    count: 10,
});
// 'https://ziggy.test/venues/1/events/2?page=5&count=10'

If you need to pass a query parameter with the same name as a route parameter, nest it under the special _query key:

route('venues.events.show', {
    venue: 1,
    event: 2,
    _query: {
        event: 3,
        page: 5,
    },
});
// 'https://ziggy.test/venues/1/events/2?event=3&page=5'

Like Laravel, Rzl Ziggy automatically encodes boolean query parameters as integers in the query string:

route('venues.events.show', {
    venue: 1,
    event: 2,
    _query: {
        draft: false,
        overdue: true,
    },
});
// 'https://ziggy.test/venues/1/events/2?draft=0&overdue=1'

Default parameter values

Rzl Ziggy supports default route parameter values (Laravel docs).

Route::get('{locale}/posts/{post}', fn (Post $post) => /* ... */)->name('posts.show');

// app/Http/Middleware/SetLocale.php

URL::defaults(['locale' => $request->user()->locale ?? 'de']);

route('posts.show', 1); // 'https://ziggy.test/de/posts/1'

Examples

HTTP request with axios:

const post = { id: 1, title: 'Ziggy Stardust' };

return axios.get(route('posts.show', post)).then((response) => response.data);

`Router` class

Calling Rzl Ziggy's route() function with no arguments will return an instance of its JavaScript Router class, which has some other useful properties and methods.

Check the current route: `route().current()`

// Laravel route called 'events.index' with URI '/events'
// Current window URL is https://ziggy.test/events

route().current();               // 'events.index'
route().current('events.index'); // true
route().current('events.*');     // true
route().current('events.show');  // false

route().current() optionally accepts parameters as its second argument, and will check that their values also match in the current URL:

// Laravel route called 'venues.events.show' with URI '/venues/{venue}/events/{event}'
// Current window URL is https://myapp.com/venues/1/events/2?hosts=all

route().current('venues.events.show', { venue: 1 });           // true
route().current('venues.events.show', { venue: 1, event: 2 }); // true
route().current('venues.events.show', { hosts: 'all' });       // true
route().current('venues.events.show', { venue: 6 });           // false

Check if a route exists: `route().has()`

// Laravel app has only one named route, 'home'

route().has('home');   // true
route().has('orders'); // false

Retrieve the current route params: `route().params`

// Laravel route called 'venues.events.show' with URI '/venues/{venue}/events/{event}'
// Current window URL is https://myapp.com/venues/1/events/2?hosts=all

route().params; // { venue: '1', event: '2', hosts: 'all' }

Note: parameter values retrieved with route().params will always be returned as strings.

Route-model binding

Rzl Ziggy supports Laravel's route-model binding, and can even recognize custom route key names. If you pass route() a JavaScript object as a route parameter, Ziggy will use the registered route-model binding keys for that route to find the correct parameter value inside the object. If no route-model binding keys are explicitly registered for a parameter, Ziggy will use the object's id key.

// app/Models/Post.php

class Post extends Model
{
    public function getRouteKeyName()
    {
        return 'slug';
    }
}

Route::get('blog/{post}', function (Post $post) {
    return view('posts.show', ['post' => $post]);
})->name('posts.show');

const post = {
    id: 3,
    title: 'Introducing Ziggy v1',
    slug: 'introducing-ziggy-v1',
    date: '2020-10-23T20:59:24.359278Z',
};

// Rzl Ziggy knows that this route uses the 'slug' route-model binding key:

route('posts.show', post); // 'https://ziggy.test/blog/introducing-ziggy-v1'

Rzl Ziggy also supports custom keys for scoped bindings declared directly in a route definition:

Route::get('authors/{author}/photos/{photo:uuid}', fn (Author $author, Photo $photo) => /* ... */)
    ->name('authors.photos.show');

const photo = {
    uuid: '714b19e8-ac5e-4dab-99ba-34dc6fdd24a5',
    filename: 'sunset.jpg',
}

route('authors.photos.show', [{ id: 1, name: 'Ansel' }, photo]);
// 'https://ziggy.test/authors/1/photos/714b19e8-ac5e-4dab-99ba-34dc6fdd24a5'

TypeScript

Rzl Ziggy includes TypeScript type definitions, and an Artisan command that can generate additional type definitions to enable route name and parameter autocompletion.

To generate route types, run the rzl-ziggy:generate command with the --types or --types-only option:

php artisan rzl-ziggy:generate --types

To make your IDE aware that Ziggy's route() helper is available globally, and to type it correctly, add a declaration like this in a .d.ts file somewhere in your project:

import { route as routeFn } from 'rzl-app-ziggy';

declare global {
    var route: typeof routeFn;
}

If you don't have Rzl Ziggy's NPM package installed, add the following to your jsconfig.json or tsconfig.json to load Rzl Ziggy's types from your vendor directory:

{
    "compilerOptions": {
        "paths": {
            "rzl-app-ziggy": ["./vendor/rzl-app/ziggy"]
        }
    }
}

JavaScript frameworks

Note

Many applications don't need the additional setup described here—the @rzlRoutes Blade directive makes Rzl Ziggy's route() function and config available globally, including within bundled JavaScript files.

If you are not using the @rzlRoutes Blade directive, you can import Ziggy's route() function and configuration directly into JavaScript/TypeScript files.

Generating and importing Rzl Ziggy's configuration

Rzl Ziggy provides an Artisan command to output its config and routes to a file:

php artisan rzl-ziggy:generate

This command places your configuration in resources/routes/index.ts by default, but you can customize this path by passing an argument to the Artisan command or setting the rzl-ziggy.output.path.main for name file and rzl-ziggy.lang valid value is (ts or js) in config value.

The file rzl-ziggy:generate creates looks something like this:

// resources/routes/index.{ts|js}

/** ---------------------------------
  * * ***Data Generates Routes of App Based-on Laravel Routes Name.***
  * ---------------------------------
  *
  * @return  string
  *
  */
export const appRoutes = {
    url: 'https://ziggy.test',
    port: null,
    routes: {
        home: {
            uri: '/',
            methods: [ 'GET', 'HEAD'],
            domain: null,
        },
        login: {
            uri: 'login',
            methods: ['GET', 'HEAD'],
            domain: null,
        },
    },
};

Importing the `route()` function

You can import Ziggy like any other JavaScript library. Without the @rzlRoutes Blade directive Rzl Ziggy's config is not available globally, so it must be passed to the route() function manually:

import { route } from '../../vendor/rzl-app/ziggy';
import { appRoutes } from './routes/index.js';

route('home', undefined, undefined, appRoutes);

To simplify importing the route() function, you can create an alias to the vendor path:

// vite.config.js

export default defineConfig({
    resolve: {
        alias: {
            'rzl-app-ziggy': path.resolve('vendor/rzl-app/ziggy'),
        },
    },
});

Now your imports can be shortened to:

import { route } from 'rzl-app-ziggy';

Vue

Ziggy includes a Vue plugin to make it easy to use the route() helper throughout your Vue app:

import { createApp } from 'vue';
import { ZiggyVue } from 'rzl-app-ziggy';
import App from './App.vue';

createApp(App).use(ZiggyVue);

Now you can use the route() function anywhere in your Vue components and templates:

<a class="nav-link" :href="route('home')">Home</a>

With <script setup> in Vue 3 you can use inject to make the route() function available in your component script:

<script setup>
import { inject } from 'vue';

const route = inject('route');
</script>

If you are not using the @rzlRoutes Blade directive, import Ziggy's configuration too and pass it to .use():

import { createApp } from 'vue';
import { ZiggyVue } from 'rzl-app-ziggy';
import { appRoutes } from './routes/index.js';
import App from './App.vue';

createApp(App).use(ZiggyVue, appRoutes);

If you're using TypeScript, you may need to add the following declaration to a .d.ts file in your project to avoid type errors when using the route() function in your Vue component templates:

declare module 'vue' {
    interface ComponentCustomProperties {
        route: typeof routeFn;
    }
}

React

Ziggy includes a useRoute() hook to make it easy to use the route() helper in your React app:

import React from 'react';
import { useRoute } from 'rzl-app-ziggy';

export default function PostsLink() {
    const route = useRoute();

    return <a href={route('posts.index')}>Posts</a>;
}

If you are not using the @rzlRoutes Blade directive, import Ziggy's configuration too and pass it to useRoute():

import React from 'react';
import { useRoute } from 'rzl-app-ziggy';
import { appRoutes } from './routes/index.js';

export default function PostsLink() {
    const route = useRoute(appRoutes);

    return <a href={route('posts.index')}>Posts</a>;
}

You can also make the Rzl Ziggy config object available globally, so you can call useRoute() without passing Rzl Ziggy's configuration to it every time:

// app.js
import { appRoutes } from './routes/index.ts';
globalThis.appRoutes = appRoutes;

SPAs or separate repos

Ziggy's route() function is available as an NPM package, for use in JavaScript projects managed separately from their Laravel backend (i.e. without Composer or a vendor directory). You can install the NPM package with npm install rzl-app-ziggy.

To make your routes available on the frontend for this function to use, you can either run php artisan rzl-ziggy:generate and add the generated config file to your frontend project, or you can return Rzl Ziggy's config as JSON from an endpoint in your Laravel API (see Retrieving Ziggy's config from an API endpoint below for an example of how to set this up).

Filtering Routes

Ziggy supports filtering the list of routes it outputs, which is useful if you have certain routes that you don't want to be included and visible in your HTML source.

Important

Hiding routes from Ziggy's output is not a replacement for thorough authentication and authorization. Routes that should not be accessibly publicly should be protected by authentication whether they're filtered out of Ziggy's output or not.

Including/excluding routes

To set up route filtering, create a config file in your Laravel app at config/rzl-ziggy.php and add either an only or except key containing an array of route name patterns.

Note: You have to choose one or the other. Setting both only and except will disable filtering altogether and return all named routes.

// config/rzl-ziggy.php

return [
    'only' => ['home', 'posts.index', 'posts.show'],
];

You can use asterisks as wildcards in route filters. In the example below, admin.* will exclude routes named admin.login, admin.register, etc.:

// config/rzl-ziggy.php

return [
    'except' => ['_debugbar.*', 'horizon.*', 'admin.*'],
];

Filtering with groups

You can also define groups of routes that you want make available in different places in your app, using a groups key in your config file:

// config/rzl-ziggy.php

return [
    'groups' => [
        'admin' => ['admin.*', 'users.*'],
        'author' => ['posts.*'],
    ],
];

Then, you can expose a specific group by passing the group name into the @rzlRoutes Blade directive:

{{-- authors.blade.php --}}

@routes('author')

To expose multiple groups you can pass an array of group names:

{{-- admin.blade.php --}}

@routes(['admin', 'author'])

Note: Passing group names to the @rzlRoutes directive will always take precedence over your other only or except settings.

Other

TLS/SSL termination and trusted proxies

If your application is using TLS/SSL termination or is behind a load balancer or proxy, or if it's hosted on a service that is, Ziggy may generate URLs with a scheme of http instead of https, even if your app URL uses https. To fix this, set up your Laravel app's trusted proxies according to the documentation on Configuring Trusted Proxies.

Using `@rzlRoutes` with a Content Security Policy

A Content Security Policy (CSP) may block inline scripts, including those output by Ziggy's @rzlRoutes Blade directive. If you have a CSP and are using a nonce to flag safe inline scripts, you can pass the nonce to the @rzlRoutes directive and it will be added to Ziggy's script tag:

@routes(nonce: 'your-nonce-here')

Disabling the `route()` helper

If you only want to use the @rzlRoutes directive to make Ziggy's configuration available in JavaScript, but don't need the route() helper function, set the rzl-ziggy.skip-route-function config to true.

Retrieving Ziggy's config from an API endpoint

If you need to retrieve Ziggy's config from your Laravel backend over the network, you can create a route that looks something like this:

// routes/api.php

use RzlApp\Ziggy\Ziggy;

Route::get('ziggy', fn () => response()->json(new Ziggy));

Re-generating the routes file when your app routes change

If you are generating your Rzl Ziggy config as a file by running php artisan rzl-ziggy:generate, you may want to re-run that command when your app's route files change. The example below is a Laravel Mix plugin, but similar functionality could be achieved without Mix. Huge thanks to Nuno Rodrigues for the idea and a sample implementation. See #655 or vite-plugin-ziggy for Vite examples.

Laravel Mix plugin example

const mix = require('laravel-mix');
const { exec } = require('child_process');

mix.extend('ziggy', new class {
    register(config = {}) {
        this.watch = config.watch ?? ['routes/**/*.php'];
        this.path = config.path ?? '';
        this.enabled = config.enabled ?? !Mix.inProduction();
    }

    boot() {
        if (!this.enabled) return;

        const command = () => exec(
            `php artisan rzl-ziggy:generate ${this.path}`,
            (error, stdout, stderr) => console.log(stdout)
        );

        command();

        if (Mix.isWatching() && this.watch) {
            ((require('chokidar')).watch(this.watch))
                .on('change', (path) => {
                    console.log(`${path} changed...`);
                    command();
                });
        };
    }
}());

mix.js('resources/js/app.js', 'public/js')
    .postCss('resources/css/app.css', 'public/css', [])
    .ziggy();

Contributing

To get started contributing to Ziggy, check out the contribution guide.

Credits

Thanks to Caleb Porzio, Adam Wathan, and Jeffrey Way for help solidifying the idea.

Security

Please review our security policy on how to report security vulnerabilities.

License

Rzl Ziggy is open-source software released under the MIT license. See LICENSE for more information.

rzl-app / ziggy

Maintainers

Details

README

Rzl Ziggy – Use your Laravel routes in JavaScript (Customize).

Installation

Usage

`route()` function

Basic usage

Parameters

Multiple parameters

Query parameters

Default parameter values

Examples

`Router` class

Check the current route: `route().current()`

Check if a route exists: `route().has()`

Retrieve the current route params: `route().params`

Route-model binding

TypeScript

JavaScript frameworks

Generating and importing Rzl Ziggy's configuration

Importing the `route()` function

Vue

React

SPAs or separate repos

Filtering Routes

Including/excluding routes

Filtering with groups

Other

TLS/SSL termination and trusted proxies

Using `@rzlRoutes` with a Content Security Policy

Disabling the `route()` helper

Retrieving Ziggy's config from an API endpoint

Re-generating the routes file when your app routes change

Contributing

Credits

Security

License

rzl-app / ziggy

Maintainers

Details

README

Rzl Ziggy – Use your Laravel routes in JavaScript (Customize).

Installation

Usage

route() function

Basic usage

Parameters

Multiple parameters

Query parameters

Default parameter values

Examples

Router class

Check the current route: route().current()

Check if a route exists: route().has()

Retrieve the current route params: route().params

Route-model binding

TypeScript

JavaScript frameworks

Generating and importing Rzl Ziggy's configuration

Importing the route() function

Vue

React

SPAs or separate repos

Filtering Routes

Including/excluding routes

Filtering with groups

Other

TLS/SSL termination and trusted proxies

Using @rzlRoutes with a Content Security Policy

Disabling the route() helper

Retrieving Ziggy's config from an API endpoint

Re-generating the routes file when your app routes change

Contributing

Credits

Security

License

`route()` function

`Router` class

Check the current route: `route().current()`

Check if a route exists: `route().has()`

Retrieve the current route params: `route().params`

Importing the `route()` function

Using `@rzlRoutes` with a Content Security Policy

Disabling the `route()` helper