Laravel Terms

https://github.com/aliziodev/laravel-taxonomy
Admin
A flexible Laravel package for managing taxonomies, categories, tags, and hierarchical structures...
Tokens:55,672
Snippets:414
Trust Score:7.3
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Installation Commands

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Install the package, publish config and migration, and run migrations. The taxonomy:install command publishes config and migration; pass --force to overwrite existing files.

```bash
composer require aliziodev/laravel-taxonomy
php artisan taxonomy:install
php artisan migrate
```

--------------------------------

### Complete Workflow Example

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

A full example of the contribution workflow: create branch, make changes, run tests, commit with conventional format, and push.

```bash
# 1. Create feature branch
git checkout -b feat/bulk-taxonomy-operations

# 2. Make changes
# ... edit files ...

# 3. Add tests
# ... create tests ...

# 4. Run tests
vendor/bin/pest
vendor/bin/phpstan analyse
vendor/bin/pint --test

# 5. Commit with conventional format
git add .
git commit -m "feat: add bulk operations for taxonomy management

Implement bulkCreate, bulkUpdate, and bulkDelete methods
to improve performance for large-scale operations.

Closes #45"

# 6. Push and create PR
git push origin feat/bulk-taxonomy-operations
```

--------------------------------

### taxonomy:install

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Installs the taxonomy package, likely publishing migrations and configuration. The --force flag allows non-interactive installation.

```APIDOC
## taxonomy:install

### Description
Installs the taxonomy package, likely publishing migrations and configuration. The --force flag allows non-interactive installation.

### Method
Artisan Command

### Endpoint
`php artisan taxonomy:install [--force]`

### Parameters
#### Options
- **--force** (flag) - Optional - Force the operation without confirmation.

### Request Example
```bash
php artisan taxonomy:install --force
```

### Response
#### Success Response
- **Output** - Command output indicating successful installation.
```

--------------------------------

### Install Dependencies with Composer

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Install PHP dependencies using Composer.

```bash
composer install
```

--------------------------------

### Verify unique constraint within same type

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

This example should fail because it attempts to create a taxonomy with the same slug and type as an existing one. Use it to confirm the unique constraint is enforced.

```php
// This should fail
Taxonomy::create([
    'name' => 'Tech',
    'slug' => 'technology', // Same slug
    'type' => TaxonomyType::Category // Same type
]);
```

--------------------------------

### Run migration

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Execute the migration to apply the schema changes.

```bash
php artisan migrate
```

--------------------------------

### Development Commands

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/AGENTS.md

Composer scripts for testing, static analysis, formatting, and running all checks. Use these during development to validate changes.

```bash
composer test      # Pest
composer analyse   # PHPStan (larastan)
composer format    # Pint
composer check     # all three
```

--------------------------------

### Store Translations in Meta

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Example of storing translations in the meta column since there is no translation layer.

```php
'meta' => ['translations' => ['id' => ['name' => 'Elektronik']]],
```

--------------------------------

### Package Structure Overview

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/AGENTS.md

Shows the main source files and their roles in the package. Use this to understand where models, traits, manager, and facade live.

```text
src/Models/Taxonomy.php      the model, the boot hooks, the nested set
src/Traits/HasTaxonomy.php   what user models get: relation, scopes, attach/sync
src/TaxonomyManager.php      what the facade proxies; caching lives here
src/Facades/Taxonomy.php     facade over the manager, NOT over the model
```

--------------------------------

### getSiblings()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get sibling nodes.

```APIDOC
## getSiblings()

### Description
Get sibling nodes.

### Method
Method

### Example
```php
$node->getSiblings();
```
```

--------------------------------

### List custom types in config

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

List custom types in config so tooling and the rebuild command know about them. The example shows the 'types' array with category, tag, season, and department.

```php
'types' => ['category', 'tag', 'season', 'department'],
```

--------------------------------

### Run taxonomy console commands

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Lists the available artisan commands: taxonomy:install with optional --force, and taxonomy:rebuild-nested-set which recomputes lft, rgt, and depth. The rebuild command is needed only when rows were written outside the model; it rebuilds every type when no type is given, uses one transaction per type, clears caches, and requires --force when running non-interactively.

```bash
php artisan taxonomy:install [--force]
php artisan taxonomy:rebuild-nested-set [type] [--force]
```

--------------------------------

### Create a term with a custom type and query by type

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Everywhere a type is accepted you may pass the enum or a plain string, so custom types need no registration. This example creates a term with type 'season' and queries products with that type.

```php
Taxonomy::create(['name' => 'Winter', 'type' => 'season']);
Product::withTaxonomyType('season')->get();
```

--------------------------------

### getChildren()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get child nodes.

```APIDOC
## getChildren()

### Description
Get child nodes.

### Method
Method

### Example
```php
$node->getChildren();
```
```

--------------------------------

### Rollback migration

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Run this command to rollback the migration. Ensure no duplicate slugs exist across types before rolling back.

```bash
php artisan migrate:rollback
```

--------------------------------

### full_slug (attribute)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get the full slug of the node, e.g., 'electronics/smartphones'.

```APIDOC
## full_slug (attribute)

### Description
Get the full slug of the node, e.g., 'electronics/smartphones'.

### Method
Attribute

### Example
```php
$node->full_slug;
```
```

--------------------------------

### path (attribute)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get the path of the node as a string, e.g., 'Electronics > Smartphones'.

```APIDOC
## path (attribute)

### Description
Get the path of the node as a string, e.g., 'Electronics > Smartphones'.

### Method
Attribute

### Example
```php
$node->path;
```
```

--------------------------------

### Build navigation menu and breadcrumbs

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/ecommerce-product-catalog.md

Shows how to get the full category tree in one query (cached) and how to build a breadcrumb trail using the path property and ancestors().

```php
// Menu: full tree, one query, cached
$menu = Taxonomy::getNestedTree(TaxonomyType::Category);

// Breadcrumb for the current category
$category->path;   // "Electronics > Smartphones > Android"

$trail = $category->ancestors()->reverse()->push($category);
```

--------------------------------

### Create migration file for unique constraint upgrade

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Run this Artisan command to generate a new migration file for upgrading the taxonomy unique constraint to v2.3.0.

```bash
php artisan make:migration upgrade_taxonomies_unique_constraint_to_v2_3
```

--------------------------------

### parent (relation)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get the parent taxonomy node.

```APIDOC
## parent (relation)

### Description
Get the parent taxonomy node.

### Method
Relation

### Example
```php
$node->parent;
```
```

--------------------------------

### Create taxonomies with same slug but different types

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Use this to verify that taxonomies with the same slug can coexist when they have different types. This is a key upgrade test scenario.

```php
Taxonomy::create([
    'name' => 'Technology',
    'slug' => 'technology',
    'type' => TaxonomyType::Category
]);

Taxonomy::create([
    'name' => 'Technology',
    'slug' => 'technology',
    'type' => TaxonomyType::Tag
]);
```

--------------------------------

### Taxonomy::flatTree($type)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get a flat list of taxonomies with depth set on each node.

```APIDOC
## Taxonomy::flatTree($type)

### Description
Get a flat list of taxonomies with depth set on each node.

### Method
Static Method

### Parameters
- `$type` (TaxonomyType) - Required - The taxonomy type.

### Example
```php
Taxonomy::flatTree(TaxonomyType::Category);
```
```

--------------------------------

### Bulk create with generator for memory efficiency

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Pass any iterable to bulkCreate(), such as a generator, to keep memory flat on large imports. The example yields rows from a LazyCollection of CSV data, with chunkSize set to 500. Slugs are generated and de-duplicated against both the batch and existing rows; an explicit duplicate slug raises DuplicateSlugException.

```php
Taxonomy::bulkCreate((function () {
    foreach (LazyCollection::make($csvRows) as $row) {
        yield ['name' => $row['name'], 'type' => 'category'];
    }
})(), chunkSize: 500);
```

--------------------------------

### $node->children

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Relation to get the direct children of a taxonomy node.

```APIDOC
## $node->children

### Description
Relation to get the direct children of a taxonomy node.

### Method
Relation (Eloquent)

### Example
```php
$node->children;
```
```

--------------------------------

### $node->parent

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Relation to get the parent of a taxonomy node.

```APIDOC
## $node->parent

### Description
Relation to get the parent of a taxonomy node.

### Method
Relation (Eloquent)

### Example
```php
$node->parent;
```
```

--------------------------------

### Bulk create taxonomies with Taxonomy::bulkCreate()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Use this method to insert many taxonomies in one pass, for seeders and imports where looping over create() is too slow. It generates and de-duplicates slugs, fills the nested set, and clears the cache, but model events are not fired.

```php
Taxonomy::bulkCreate([
    ['name' => 'Electronics', 'type' => TaxonomyType::Category],
    ['name' => 'Books',       'type' => TaxonomyType::Category],
]);
```

--------------------------------

### Read and check taxonomies

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Methods to retrieve taxonomy relations and check membership. taxonomies returns the relation, taxonomiesOfType filters by type, getFirstTaxonomyOfType gets the first match, and getTaxonomyCountByType counts. hasTaxonomies checks if any of the given ids are present, hasAllTaxonomies checks if all are present, and hasTaxonomyType checks if any taxonomy of a type exists.

```php
$product->taxonomies;                                    // relation
$product->taxonomiesOfType(TaxonomyType::Category);      // Collection
$product->getFirstTaxonomyOfType(TaxonomyType::Category);
$product->getTaxonomyCountByType(TaxonomyType::Tag);

$product->hasTaxonomies([$a->id]);                       // any of
$product->hasAllTaxonomies([$a->id, $b->id]);            // all of
$product->hasTaxonomyType(TaxonomyType::Category);       // any of this type
```

--------------------------------

### Check for slug conflicts across types

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Run this query to identify potential slug conflicts before migrating. It groups by slug and finds slugs that appear in more than one type, printing each conflict.

```php
// Check for potential slug conflicts across different types
$conflicts = DB::table('taxonomies')
    ->select('slug')
    ->groupBy('slug')
    ->havingRaw('COUNT(DISTINCT type) > 1')
    ->get();

if ($conflicts->isNotEmpty()) {
    // Handle conflicts manually or update slugs
    foreach ($conflicts as $conflict) {
        echo "Conflict found for slug: {$conflict->slug}\n";
    }
}
```

--------------------------------

### Custom queries after v2.3.0

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Updated queries that include type constraints to respect the composite unique constraint. Includes model, facade, and scope examples.

```php
// Using model with type constraint
$taxonomy = Taxonomy::where('slug', 'technology')
    ->where('type', TaxonomyType::Category)
    ->first();

// Using facade with type constraint
$taxonomy = \Aliziodev\LaravelTaxonomy\Facades\Taxonomy::findBySlug('technology', TaxonomyType::Category);

// Or using available scope
$taxonomy = Taxonomy::type(TaxonomyType::Category)
    ->where('slug', 'technology')
    ->first();
```

--------------------------------

### Deprecated custom relationship name example

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Passing a custom relationship name to taxonomy methods is deprecated and will be removed in 3.0. This call fails with 'no such column: taxonomables.categories_id' because the migration only creates taxonomable_id and taxonomable_type columns.

```php
$product->attachTaxonomies($categoryIds, 'categories');
```

--------------------------------

### Clone and Enter Repository

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Clone the repository from your fork and navigate into the project directory.

```bash
git clone https://github.com/your-username/laravel-taxonomy.git
cd laravel-taxonomy
```

--------------------------------

### Register cache scope resolver for multi-tenant isolation

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Use this in multi-tenant applications to isolate cached taxonomy trees per tenant. Register a resolver that returns the current tenant's key; without it, cache keys remain global and one tenant could receive another's cached tree.

```php
use Aliziodev\LaravelTaxonomy\TaxonomyManager;

TaxonomyManager::resolveCacheScopeUsing(fn () => tenant()?->getKey());
```

--------------------------------

### Run Migrations for Tenant Connection

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Run migrations for a tenant connection using the specified path and database connection.

```bash
php artisan migrate --path=database/migrations/tenants --database=tenant
```

--------------------------------

### Taxonomy facade method reference

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Lists all methods available on the Taxonomy facade, including create, bulkCreate, find, search, tree methods, and cache clearing. Note that the facade is not an Eloquent builder; use the model for query building.

```php
Taxonomy::create($attributes);                   // create
Taxonomy::createOrUpdate($attributes);           // create, or update a matching slug+type
Taxonomy::bulkCreate($rows, $chunkSize = 1000);   // insert many at once, no model events
Taxonomy::find($id);
Taxonomy::findMany($ids, $perPage = null, $page = 1);
Taxonomy::findBySlug('smartphones', TaxonomyType::Category);
Taxonomy::findByType(TaxonomyType::Category, $perPage = null, $page = 1);
Taxonomy::findByParent($parentId, $perPage = null, $page = 1);
Taxonomy::search('phone', TaxonomyType::Category, $perPage = null, $page = 1);
Taxonomy::exists('smartphones', TaxonomyType::Category);
Taxonomy::getTypes();                            // Support\Collection<string>

Taxonomy::tree($type = null, $parentId = null);        // nested, one level of children
Taxonomy::flatTree($type = null, $parentId = null);    // flat, each node carries `depth`
Taxonomy::getNestedTree($type = null);                 // fully nested, via the nested set

Taxonomy::getDescendants($taxonomyId);
Taxonomy::getAncestors($taxonomyId);
Taxonomy::moveToParent($taxonomyId, $parentId);
Taxonomy::rebuildNestedSet($type);
Taxonomy::clearCacheForType($type);
```

--------------------------------

### Publish Config and Migrations Individually

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Publish only the config or only the migrations using vendor:publish tags.

```bash
php artisan vendor:publish --tag=taxonomy-config
php artisan vendor:publish --tag=taxonomy-migrations
```

--------------------------------

### getLevel()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get the depth level of the node (0 for roots).

```APIDOC
## getLevel()

### Description
Get the depth level of the node (0 for roots).

### Method
Method

### Example
```php
$node->getLevel();
```
```

--------------------------------

### Run test, analysis, and formatting commands

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Commands for contributing: composer test runs Pest, composer analyse runs PHPStan, and composer format runs Pint.

```bash
composer test      # Pest
composer analyse   # PHPStan
composer format    # Pint

```

--------------------------------

### children (relation)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get the child taxonomy nodes, ordered by sort_order.

```APIDOC
## children (relation)

### Description
Get the child taxonomy nodes, ordered by sort_order.

### Method
Relation

### Example
```php
$node->children;
```
```

--------------------------------

### getDescendants()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get descendant nodes using nested set, single query.

```APIDOC
## getDescendants()

### Description
Get descendant nodes using nested set, single query.

### Method
Method

### Example
```php
$node->getDescendants();
```
```

--------------------------------

### getAncestors()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get ancestor nodes using nested set, single query.

```APIDOC
## getAncestors()

### Description
Get ancestor nodes using nested set, single query.

### Method
Method

### Example
```php
$node->getAncestors();
```
```

--------------------------------

### Create Taxonomy with Metadata

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Shows how to create a taxonomy with a meta JSON column cast to array, access meta values, and query using JSON operators.

```php
Taxonomy::create([
    'name' => 'Electronics',
    'type' => TaxonomyType::Category,
    'meta' => ['icon' => 'devices', 'color' => '#3498db', 'featured' => true],
]);

$taxonomy->meta['icon'];

TaxonomyModel::where('meta->featured', true)->get();
TaxonomyModel::whereJsonContains('meta->tags', 'sale')->get();
```

--------------------------------

### Query building with Taxonomy model

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Shows how to use the Taxonomy model for query building, since the facade does not support Eloquent builder methods like where(). The type() and ordered() scopes are used.

```php
use Aliziodev\LaravelTaxonomy\Models\Taxonomy as TaxonomyModel;

TaxonomyModel::type(TaxonomyType::Category)->ordered()->get();
```

--------------------------------

### Taxonomy::getNestedTree($type)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get a full depth nested tree with children_nested and tree_depth.

```APIDOC
## Taxonomy::getNestedTree($type)

### Description
Get a full depth nested tree with children_nested and tree_depth.

### Method
Static Method

### Parameters
- `$type` (TaxonomyType) - Required - The taxonomy type.

### Example
```php
Taxonomy::getNestedTree(TaxonomyType::Category);
```
```

--------------------------------

### Configure Custom Model in Config

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Configuration to point the package at the custom Taxonomy model.

```php
'model' => \App\Models\Taxonomy::class,
```

--------------------------------

### $node->path

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Returns the path of the node as a string, e.g., 'Electronics > Smartphones'.

```APIDOC
## $node->path

### Description
Returns the path of the node as a string, e.g., 'Electronics > Smartphones'.

### Method
Property (Eloquent)

### Example
```php
$node->path;
```
```

--------------------------------

### Taxonomy::tree($type)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get roots with one level eager-loaded for a given taxonomy type.

```APIDOC
## Taxonomy::tree($type)

### Description
Get roots with one level eager-loaded for a given taxonomy type.

### Method
Static Method

### Parameters
- `$type` (TaxonomyType) - Required - The taxonomy type.

### Example
```php
Taxonomy::tree(TaxonomyType::Category);
```
```

--------------------------------

### Create Feature Branch

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Create a new branch for your feature work.

```bash
git checkout -b feat/your-feature-name
```

--------------------------------

### ancestors()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get ancestor nodes by walking parent_id. Correct even if nested set has drifted.

```APIDOC
## ancestors()

### Description
Get ancestor nodes by walking parent_id. Correct even if nested set has drifted.

### Method
Method

### Example
```php
$node->ancestors();
```
```

--------------------------------

### Push and Create Pull Request

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Push the feature branch to your fork and create a pull request.

```bash
git push origin feat/your-feature-name
```

--------------------------------

### Run Tests with PestPHP

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Run all tests, a specific test file, or with coverage using PestPHP.

```bash
# Semua tests
vendor/bin/pest

# Specific test file
vendor/bin/pest tests/Feature/TaxonomyFeatureTest.php

# Dengan coverage
vendor/bin/pest --coverage
```

--------------------------------

### Add Tenant Column and Unique Index

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Migration to add a tenant_id column and replace the unique index to allow same slugs across tenants.

```php
Schema::table('taxonomies', function (Blueprint $table) {
    $table->dropUnique(['slug', 'type', 'deleted_at']);
    $table->foreignId('tenant_id')->nullable()->index();
    $table->unique(['tenant_id', 'slug', 'type', 'deleted_at']);
});
```

--------------------------------

### descendants()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Get descendant nodes depth-first, one query per level. Keyed on id, immune to stale nested set.

```APIDOC
## descendants()

### Description
Get descendant nodes depth-first, one query per level. Keyed on id, immune to stale nested set.

### Method
Method

### Example
```php
$node->descendants();
```
```

--------------------------------

### Run PHPStan Static Analysis

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Run PHPStan to perform static analysis on the codebase.

```bash
# Static analysis
vendor/bin/phpstan analyse
```

--------------------------------

### Product::syncTaxonomies

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Replaces all taxonomy associations on the model with the given set. Accepts an array of taxonomy IDs or model instances.

```APIDOC
## Product::syncTaxonomies

### Description
Replaces all taxonomy associations on the model with the given set. Accepts an array of taxonomy IDs or model instances.

### Method
Instance method on a model using the HasTaxonomy trait.

### Parameters
- **taxonomies** (array) - Required - Array of taxonomy IDs or model instances.

### Request Example
```php
$product->syncTaxonomies([$a->id, $b->id]);  // replace all
```

### Response
No return value (void).
```

--------------------------------

### Custom queries before v2.3.0

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Old queries that rely on global slug uniqueness. These need to be updated to include type constraints.

```php
// Using model directly
$taxonomy = Taxonomy::where('slug', 'technology')->first();

// Or using facade
$taxonomy = \Aliziodev\LaravelTaxonomy\Facades\Taxonomy::findBySlug('technology');
```

--------------------------------

### Validation rule before v2.3.0

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Old validation rule that enforces global slug uniqueness. Replace with the new composite rule.

```php
'slug' => 'required|string|unique:taxonomies,slug'
```

--------------------------------

### Create taxonomy terms with Taxonomy facade

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Creates a category and a child category using the Taxonomy facade. The parent_id links the child to the parent term.

```php
use Aliziodev\LaravelTaxonomy\Facades\Taxonomy;
use Aliziodev\LaravelTaxonomy\Enums\TaxonomyType;

$electronics = Taxonomy::create([
    'name' => 'Electronics',
    'type' => TaxonomyType::Category,
    'meta' => ['icon' => 'devices'],
]);

$phones = Taxonomy::create([
    'name'      => 'Smartphones',
    'type'      => TaxonomyType::Category,
    'parent_id' => $electronics->id,
]);
```

--------------------------------

### Taxonomy::bulkCreate()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Bulk create taxonomy records with optimized performance. Resolves slugs in memory, inserts in chunks, and renumbers the nested set once at the end, reducing queries significantly compared to create().

```APIDOC
## [POST] Taxonomy::bulkCreate()

### Description
Bulk create taxonomy records with optimized performance. Resolves slugs in memory, inserts in chunks, and renumbers the nested set once at the end, reducing queries significantly compared to create().

### Method
POST

### Endpoint
Taxonomy::bulkCreate()

### Parameters
#### Request Body
- **rows** (iterable) - Required - An iterable of associative arrays, each representing a taxonomy record. Each row must contain `name` and `type`; optional fields include `slug`, `description`, `parent_id`, `sort_order`, `meta`, `created_at`, and `updated_at`.
- **chunkSize** (int) - Optional - The number of rows to insert per chunk. Defaults to a reasonable value.

### Request Example
```php
Taxonomy::bulkCreate([
    ['name' => 'Electronics', 'type' => TaxonomyType::Category],
    ['name' => 'Books',       'type' => TaxonomyType::Category, 'sort_order' => 2],
    ['name' => 'Fiction',     'type' => TaxonomyType::Category, 'parent_id' => $booksId],
]);
```

### Response
#### Success Response (200)
- **created** (array) - The created taxonomy records.

#### Response Example
```php
[
    ['id' => 1, 'name' => 'Electronics', 'type' => 'category'],
    ['id' => 2, 'name' => 'Books', 'type' => 'category', 'sort_order' => 2],
    ['id' => 3, 'name' => 'Fiction', 'type' => 'category', 'parent_id' => 2],
]
```

### Error Handling
- **DuplicateSlugException** - Thrown if an explicit slug is already taken, either in the batch or in the table.

### Notes
- Model events are not fired. If you rely on observers or hooks, use `create()` instead.
- The method handles slug generation, nested set values, and cache invalidation internally.
```

--------------------------------

### Bulk create taxonomy rows with bulkCreate()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Use bulkCreate() to insert many taxonomy rows efficiently, resolving slugs in memory and renumbering the nested set once at the end. Accepts an array of rows with required 'name' and 'type' fields, plus optional fields like 'parent_id' and 'sort_order'. Model events are not fired, so avoid this if you rely on observers or creating/created hooks.

```php
Taxonomy::bulkCreate([
    ['name' => 'Electronics', 'type' => TaxonomyType::Category],
    ['name' => 'Books',       'type' => TaxonomyType::Category, 'sort_order' => 2],
    ['name' => 'Fiction',     'type' => TaxonomyType::Category, 'parent_id' => $booksId],
]);
```

--------------------------------

### Chaining taxonomy scopes

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Shows how to combine multiple taxonomy scopes in a single query. Because scopes chain, the result is an AND of all conditions.

```php
Product::withTaxonomySlug('smartphones', TaxonomyType::Category)
    ->withAnyTaxonomiesOfType(TaxonomyType::Tag, $featuredIds)
    ->get();
```

--------------------------------

### Validation rule after v2.3.0

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

New validation rule that enforces slug uniqueness within a specific type using Rule::unique with a where clause.

```php
'slug' => [
    'required',
    'string',
    Rule::unique('taxonomies')->where(function ($query) use ($type) {
        return $query->where('type', $type);
    })
]
```

--------------------------------

### Find related articles by shared tags

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/content-management-system.md

Gets articles that share any tag with the current article, excluding itself, limited to 5 published results.

```php
$tagIds = $article->taxonomiesOfType(TaxonomyType::Tag)->pluck('id');

$related = Article::withAnyTaxonomiesOfType(TaxonomyType::Tag, $tagIds)
    ->whereKeyNot($article->getKey())
    ->where('status', 'published')
    ->limit(5)
    ->get();
```

--------------------------------

### Custom Taxonomy Model with Global Scope

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Extends the package's Taxonomy model and adds a global scope to filter by tenant_id.

```php
namespace App\Models;

use Aliziodev\LaravelTaxonomy\Models\Taxonomy as BaseTaxonomy;

class Taxonomy extends BaseTaxonomy
{
    protected static function boot(): void
    {
        parent::boot();

        static::addGlobalScope('tenant', function ($query) {
            if ($tenantId = tenant()?->getKey()) {
                $query->where('tenant_id', $tenantId);
            }
        });
    }
}
```

--------------------------------

### Check and Fix Code Style with Laravel Pint

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Check code style with --test or automatically fix issues.

```bash
# Check code style
vendor/bin/pint --test

# Fix code style
vendor/bin/pint
```

--------------------------------

### Create categories and tags

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/content-management-system.md

Creates a category with metadata, a child category, and multiple tags.

```php
$news = Taxonomy::create([
    'name' => 'News',
    'type' => TaxonomyType::Category,
    'meta' => ['icon' => 'newspaper', 'colour' => '#2563eb'],
]);

$releases = Taxonomy::create([
    'name'      => 'Product Releases',
    'type'      => TaxonomyType::Category,
    'parent_id' => $news->id,
]);

foreach (['Laravel', 'PHP', 'Testing'] as $tag) {
    Taxonomy::create(['name' => $tag, 'type' => TaxonomyType::Tag]);
}
```

--------------------------------

### Import the Taxonomy facade and model

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Use the facade for create, find, and tree operations; use the model for query building. The facade has no where(), whereIn(), withCount(), or delete() methods.

```php
use Aliziodev\LaravelTaxonomy\Facades\Taxonomy;            // create, find, tree
use Aliziodev\LaravelTaxonomy\Models\Taxonomy as TaxonomyModel;  // query building
```

--------------------------------

### Rebuild nested set after upgrade

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Run this artisan command once after upgrading to v2.12.1 if you have deleted terms in any of the ways that left the nested set wrong. It rebuilds the nested set and fixes the lft/rgt values.

```bash
php artisan taxonomy:rebuild-nested-set --force
```

--------------------------------

### Attach, sync, detach, and toggle taxonomies

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Core methods for managing taxonomy relations on a model. attachTaxonomies adds while keeping existing, syncTaxonomies replaces all, detachTaxonomies removes some or all, and toggleTaxonomies flips membership. Each accepts an id, a Taxonomy, an array, or any collection.

```php
$product->attachTaxonomies([$a->id, $b->id]);   // add, keep existing
$product->syncTaxonomies([$a->id, $b->id]);     // replace all
$product->detachTaxonomies([$a->id]);           // remove some
$product->detachTaxonomies();                   // remove all
$product->toggleTaxonomies([$a->id]);           // flip
```

```php
$product->attachTaxonomies($taxonomy);
$product->attachTaxonomies(collect([$a, $b]));
$product->attachTaxonomies(TaxonomyModel::type('category')->pluck('id'));
```

--------------------------------

### Migration content for composite unique constraint

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/UPGRADE.md

Add this content to the generated migration file. It drops the old global unique constraint on 'slug' and adds a composite unique constraint on ['slug', 'type']. The down() method reverses these changes.

```php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        $tableNames = config('taxonomy.table_names');
        $tableName = $tableNames['taxonomies'] ?? 'taxonomies';
        
        Schema::table($tableName, function (Blueprint $table) {
            // Drop the old unique constraint on slug
            $table->dropUnique(['slug']);
            
            // Add the new composite unique constraint
            $table->unique(['slug', 'type']);
        });
    }

    public function down(): void
    {
        $tableNames = config('taxonomy.table_names');
        $tableName = $tableNames['taxonomies'] ?? 'taxonomies';
        
        Schema::table($tableName, function (Blueprint $table) {
            // Drop the composite unique constraint
            $table->dropUnique(['slug', 'type']);
            
            // Restore the old unique constraint on slug
            $table->unique(['slug']);
        });
    }
};
```

--------------------------------

### Faceted filtering with filterByTaxonomies

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/ecommerce-product-catalog.md

Maps a request payload onto types. Values within one type are OR-ed; separate types are AND-ed. The example shows a query string ?category=android&color[]=red&color[]=blue.

```php
// ?category=android&color[]=red&color[]=blue
Product::filterByTaxonomies([
    'category' => $request->input('category'),   // type => slug
    'color'    => $request->input('color', []),  // red OR blue
])->paginate(24);
```

--------------------------------

### Register cache scope resolver for multi-tenancy

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Use in AppServiceProvider::boot() to make cache keys tenant-specific. Without this, cache keys are global and one tenant can be served another tenant's tree.

```php
use Aliziodev\LaravelTaxonomy\TaxonomyManager;

// AppServiceProvider::boot()
TaxonomyManager::resolveCacheScopeUsing(fn () => tenant()?->getKey());
```

--------------------------------

### Attach taxonomies and query by slug

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Attaches taxonomy terms to a model instance and demonstrates querying attached terms and filtering by slug using the withTaxonomySlug scope.

```php
$product->attachTaxonomies([$phones->id]);
$product->taxonomies;                                  // all attached terms
Product::withTaxonomySlug('smartphones')->get();       // filter by slug
```

--------------------------------

### Default Configuration File

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Shipped config/taxonomy.php defaults. morph_type must match your model keys and cannot be changed after migration. migrations.autoload controls whether the package registers its migration path.

```php
return [
    'table_names' => [
        'taxonomies'   => 'taxonomies',
        'taxonomables' => 'taxonomables',
    ],

    // Morph column type on the pivot: 'numeric', 'uuid' or 'ulid'.
    // Must match how YOUR models are keyed. Set before the first migrate.
    'morph_type' => 'uuid',

    'types' => collect(TaxonomyType::cases())->pluck('value')->toArray(),

    // Swap in your own model; it must extend the package's Taxonomy.
    'model' => Taxonomy::class,

    'slugs' => [
        'generate'               => true,  // auto-generate from name when omitted
        'regenerate_on_update'   => true,  // rewrite the slug when the name changes
        'consider_trashed'       => false, // count soft-deleted rows when checking uniqueness
        'regenerate_on_restore'  => true,  // resolve a conflict on restore instead of throwing
    ],

    'cache' => [
        'ttl'   => 86400, // seconds
        'scope' => null,  // see Multi-tenancy
    ],

    'migrations' => [
        'autoload' => env('TAXONOMY_AUTOLOAD_MIGRATIONS', true),
        'paths'    => [],
    ],
];
```

--------------------------------

### Commit Changes with Conventional Format

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/CONTRIBUTING.md

Stage all changes and commit with a conventional commit message.

```bash
# Use conventional commits format
git add .
git commit -m "feat: add new taxonomy validation method"
```

--------------------------------

### Bulk create taxonomies with bulkCreate()

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Use bulkCreate() for seeders and imports instead of looping over create(), which costs four to seven queries per row. Measured at 0.95s and 32 queries for 10,000 rows versus 14.8s and 40,000 queries for the loop. It accepts any iterable (a generator keeps memory flat), generates slugs, fills the nested set, and clears the cache, but does not fire model events.

```php
Taxonomy::bulkCreate([
    ['name' => 'Electronics', 'type' => TaxonomyType::Category],
    ['name' => 'Fiction', 'type' => TaxonomyType::Category, 'parent_id' => $booksId],
]);
```

--------------------------------

### Build navigation menus and breadcrumbs

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/content-management-system.md

Retrieves a nested category tree, top-level categories, and breadcrumb path for a category.

```php
// Category menu: full depth, one query, cached
$menu = Taxonomy::getNestedTree(TaxonomyType::Category);

// Top-level only
TaxonomyModel::type(TaxonomyType::Category)->root()->ordered()->get();

// Breadcrumb
$category->path;                                        // "News > Product Releases"
$category->ancestors()->reverse()->push($category);     // Collection
```

--------------------------------

### Taxonomy::create

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Creates a new taxonomy term. Accepts a name, type (enum or string), optional meta data, and optional parent_id for hierarchical terms.

```APIDOC
## Taxonomy::create

### Description
Creates a new taxonomy term. Accepts a name, type (enum or string), optional meta data, and optional parent_id for hierarchical terms.

### Method
Static method on the Taxonomy model.

### Parameters
- **name** (string) - Required - The term name.
- **type** (TaxonomyType|string) - Required - The taxonomy type (e.g., Category, Tag, or custom string).
- **meta** (array) - Optional - Additional metadata for the term.
- **parent_id** (int) - Optional - ID of the parent term for hierarchical taxonomies.

### Request Example
```php
use Aliziodev\LaravelTaxonomy\Enums\TaxonomyType;

$electronics = Taxonomy::create([
    'name' => 'Electronics',
    'type' => TaxonomyType::Category,   // or any string: 'color', 'season'
    'meta' => ['icon' => 'devices'],
]);

$phones = Taxonomy::create([
    'name'      => 'Smartphones',
    'type'      => TaxonomyType::Category,
    'parent_id' => $electronics->id,
]);
```

### Response
Returns the created Taxonomy model instance.
```

--------------------------------

### Tree retrieval methods

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Provides three ways to retrieve taxonomy trees: tree() returns roots with one level eager-loaded, flatTree() returns a flat list with depth set on each node, and getNestedTree() returns the full depth with children_nested and tree_depth.

```php
Taxonomy::tree(TaxonomyType::Category);          // roots with one level eager-loaded
Taxonomy::flatTree(TaxonomyType::Category);      // flat list, `depth` set on each node
Taxonomy::getNestedTree(TaxonomyType::Category); // full depth, `children_nested` + `tree_depth`
```

--------------------------------

### Taxonomy::create

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Creates a new taxonomy term with the given attributes. Returns the created taxonomy model.

```APIDOC
## Taxonomy::create

### Description
Creates a new taxonomy term with the given attributes.

### Method
`Taxonomy::create($attributes)`

### Parameters
- **$attributes** (array) - Required - Associative array of taxonomy attributes, e.g., `name`, `type`, `meta`, `parent_id`.

### Request Example
```php
Taxonomy::create([
    'name' => 'Electronics',
    'type' => TaxonomyType::Category,
    'meta' => ['icon' => 'devices'],
]);
```

### Response
Returns the created taxonomy model instance.
```

--------------------------------

### Taxonomy::create

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Creates a new taxonomy entry with automatic slug generation. Slugs are unique within a type, and exceptions are thrown for duplicate or missing slugs.

```APIDOC
## Taxonomy::create

### Description
Creates a new taxonomy entry with automatic slug generation. Slugs are unique within a type, and exceptions are thrown for duplicate or missing slugs.

### Method
Taxonomy::create

### Parameters
#### Request Body
- **name** (string) - Required - The name of the taxonomy entry.
- **slug** (string) - Optional - Custom slug; if not provided, generated from name.
- **type** (TaxonomyType|string) - Required - The taxonomy type (e.g., 'category', 'tag').

### Request Example
```php
Taxonomy::create(['name' => 'Electronics', 'type' => TaxonomyType::Category]);
```

### Response
#### Success Response
- **Taxonomy** - The created taxonomy model instance.

#### Response Example
```php
// Returns a Taxonomy instance with slug 'electronics'
```

### Error Handling
- **DuplicateSlugException** - Thrown when the slug already exists within the type. Methods: `getSlug()`, `getType()`.
- **MissingSlugException** - Thrown when `slugs.generate` is `false` and no slug was supplied.
```

--------------------------------

### Hierarchy relations and methods

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Lists the relations and methods available on a taxonomy node. Hierarchy is stored as parent_id and nested-set lft/rgt/depth columns kept in sync automatically. getAncestors()/getDescendants() use the nested set for speed; ancestors()/descendants() follow parent_id and stay correct even if lft/rgt drift. moveToParent() throws on a circular move.

```php
$node->parent;              // relation
$node->children;            // relation, ordered by sort_order
$node->ancestors();         // walks parent_id — correct even if lft/rgt drifted
$node->descendants();       // depth-first, one query per level
$node->getAncestors();      // nested set, single query
$node->getDescendants();    // nested set, single query
$node->getSiblings();
$node->getChildren();

$node->isAncestorOf($other);
$node->isDescendantOf($other);
$node->getLevel();          // depth, 0 for roots

$node->path;                // "Electronics > Smartphones"
$node->full_slug;           // "electronics/smartphones"

$node->moveToParent($newParentId);   // throws on a circular move
```

--------------------------------

### $node->moveToParent($id)

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Moves the node to a new parent. Throws an exception on a circular move.

```APIDOC
## $node->moveToParent($id)

### Description
Moves the node to a new parent. Throws an exception on a circular move.

### Method
Method (Eloquent)

### Parameters
- **$id** (int) - Required - The new parent taxonomy ID

### Example
```php
$node->moveToParent($id);
```
```

--------------------------------

### Import taxonomy classes

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/content-management-system.md

Required imports for using the taxonomy package.

```php
use Aliziodev\LaravelTaxonomy\Enums\TaxonomyType;
use Aliziodev\LaravelTaxonomy\Facades\Taxonomy;
use Aliziodev\LaravelTaxonomy\Models\Taxonomy as TaxonomyModel;
```

--------------------------------

### Create taxonomy entries with auto-generated and custom slugs

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/README.md

Slugs are generated from the name and are unique within a type, so a 'featured' category and a 'featured' tag can coexist. The first two calls create a category with slug 'electronics' and 'electronics-1' respectively; the third uses a custom slug 'custom'.

```php
Taxonomy::create(['name' => 'Electronics', 'type' => TaxonomyType::Category]);           // 'electronics'
Taxonomy::create(['name' => 'Electronics', 'type' => TaxonomyType::Category]);           // 'electronics-1'
Taxonomy::create(['name' => 'Electronics', 'slug' => 'custom', 'type' => 'category']);   // 'custom'
```

--------------------------------

### Create flat attributes and tags with custom types

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/docs/en/ecommerce-product-catalog.md

Creates flat attributes (color, size) and a tag using custom type strings. Custom types need no registration; listing them in config('taxonomy.types') only helps tooling and the rebuild command.

```php
foreach ([['Red', '#ef4444'], ['Blue', '#3b82f6']] as [$name, $hex]) {
    Taxonomy::create(['name' => $name, 'type' => 'color', 'meta' => ['hex' => $hex]]);
}

foreach (['S', 'M', 'L', 'XL'] as $i => $size) {
    Taxonomy::create(['name' => $size, 'type' => 'size', 'sort_order' => $i]);
}

Taxonomy::create(['name' => 'Bestseller', 'type' => TaxonomyType::Tag]);
```

--------------------------------

### Product::attachTaxonomies

Source: https://github.com/aliziodev/laravel-taxonomy/blob/master/resources/boost/skills/laravel-taxonomy/SKILL.md

Attaches taxonomy terms to a model. Accepts an array of taxonomy IDs or model instances. Slugs are not accepted.

```APIDOC
## Product::attachTaxonomies

### Description
Attaches taxonomy terms to a model. Accepts an array of taxonomy IDs or model instances. Slugs are not accepted.

### Method
Instance method on a model using the HasTaxonomy trait.

### Parameters
- **taxonomies** (array) - Required - Array of taxonomy IDs or model instances.

### Request Example
```php
$product->attachTaxonomies([$phones->id]);   // add
```

### Response
No return value (void).
```
Tokens:
Raw