Building and publishing a Laravel package

install/packages/indian-rules/composer.json

{
    "name": "pathshala/indian-rules",
    "description": "Validation rules for Indian identifiers (PAN, GSTIN, IFSC, PIN code) for Laravel, with English and Hindi messages.",
    "type": "library",
    "license": "MIT",
    "keywords": ["laravel", "validation", "india"],
    "require": {
        "php": "^8.3",
        "composer-runtime-api": "^2.2",
        "illuminate/console": "^12.0 || ^13.0",
        "illuminate/contracts": "^12.0 || ^13.0",
        "illuminate/support": "^12.0 || ^13.0",
        "illuminate/validation": "^12.0 || ^13.0"
    },
    "require-dev": {
        "orchestra/testbench": "^10.12 || ^11.3"
    },
    "autoload": {
        "psr-4": {
            "Pathshala\\IndianRules\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Pathshala\\IndianRules\\Tests\\": "tests/"
        }
    },
    "extra": {
        "laravel": {
            "providers": [
                "Pathshala\\IndianRules\\IndianRulesServiceProvider"
            ],
            "aliases": {
                "IndianRules": "Pathshala\\IndianRules\\Facades\\IndianRules"
            }
        }
    },
    "scripts": {
        "test": "phpunit"
    },
    "config": {
        "sort-packages": true
    }
}

Service provider · install/packages/indian-rules/src/IndianRulesServiceProvider.php

<?php

namespace Pathshala\IndianRules;

use Composer\InstalledVersions;
use Illuminate\Foundation\Console\AboutCommand;
use Illuminate\Support\ServiceProvider;
use Pathshala\IndianRules\Console\CheckCommand;

class IndianRulesServiceProvider extends ServiceProvider
{
    /**
     * Bind the package's services and merge its default config under the app's own copy.
     */
    public function register(): void
    {
        $this->mergeConfigFrom(__DIR__.'/../config/indian-rules.php', 'indian-rules');

        $this->app->singleton(IndianRules::class);
    }

    /**
     * Tell Laravel where the translations are, what an app may publish, and what the package adds to Artisan.
     */
    public function boot(): void
    {
        $this->loadTranslationsFrom(__DIR__.'/../lang', 'indian-rules');

        $this->publishes([
            __DIR__.'/../config/indian-rules.php' => config_path('indian-rules.php'),
        ], 'indian-rules-config');

        $this->publishes([
            __DIR__.'/../lang' => $this->app->langPath('vendor/indian-rules'),
        ], 'indian-rules-lang');

        if ($this->app->runningInConsole()) {
            $this->commands([CheckCommand::class]);

            AboutCommand::add('Indian rules', fn () => [
                'Version' => InstalledVersions::getPrettyVersion('pathshala/indian-rules'),
                'Normalise input' => config('indian-rules.normalise') ? 'on' : 'off',
            ]);
        }
    }
}

install/packages/indian-rules/src/IndianRules.php

<?php

namespace Pathshala\IndianRules;

use Illuminate\Contracts\Config\Repository;

/**
 * The checks the package's rule classes share, and the object the IndianRules facade reaches.
 */
class IndianRules
{
    private const BASE36 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';

    public function __construct(private Repository $config)
    {
    }

    /**
     * The value as the rules read it: in capitals and without spaces, unless the app turned that off.
     */
    public function normalise(string $value): string
    {
        if (! $this->config->get('indian-rules.normalise')) {
            return $value;
        }

        return strtoupper(str_replace(' ', '', $value));
    }

    /**
     * Ten characters, in the shape this package accepts: five letters, four digits and a letter.
     */
    public function isPan(string $value): bool
    {
        return preg_match('/^[A-Z]{5}[0-9]{4}[A-Z]$/', $this->normalise($value)) === 1;
    }

    /**
     * Eleven characters: four letters for the bank, a zero, then six letters or digits for the branch.
     */
    public function isIfsc(string $value): bool
    {
        return preg_match('/^[A-Z]{4}0[A-Z0-9]{6}$/', $this->normalise($value)) === 1;
    }

    /**
     * Six digits; "411 001" is read as 411001 while normalising is on.
     */
    public function isPincode(string $value): bool
    {
        return preg_match('/^[0-9]{6}$/', $this->normalise($value)) === 1;
    }

    /**
     * What is wrong with a 15-character tax number: 'shape', 'state', 'check', or null when nothing is.
     * The shape: a two-digit state code, a PAN, a two-character entity code and one check character.
     */
    public function gstinProblem(string $value): ?string
    {
        $value = $this->normalise($value);

        if (preg_match('/^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z][0-9A-Z]{2}[0-9A-Z]$/', $value) !== 1) {
            return 'shape';
        }

        $states = $this->config->get('indian-rules.gstin.states');
        if (is_array($states) && ! in_array(substr($value, 0, 2), $states, true)) {
            return 'state';
        }

        if ($this->config->get('indian-rules.gstin.check_character') && $value[14] !== $this->checkCharacter(substr($value, 0, 14))) {
            return 'check';
        }

        return null;
    }

    /**
     * The check character of the first fourteen characters, computed as Luhn mod 36 over their base-36 values.
     * The rules that define the number say there is one check character, not how it is computed: compare this
     * with the issuer's published method before a live form refuses numbers with it.
     */
    public function checkCharacter(string $first14): string
    {
        $sum = 0;
        $factor = 2;

        for ($i = 13; $i >= 0; $i--) {
            $addend = $factor * strpos(self::BASE36, $first14[$i]);
            $factor = $factor === 2 ? 1 : 2;
            $sum += intdiv($addend, 36) + $addend % 36;
        }

        return self::BASE36[(36 - $sum % 36) % 36];
    }
}

Rules/Pan.php · install/packages/indian-rules/src/Rules/Pan.php

<?php

namespace Pathshala\IndianRules\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;
use Pathshala\IndianRules\IndianRules;

class Pan implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (! is_string($value) || ! app(IndianRules::class)->isPan($value)) {
            $fail('indian-rules::validation.pan')->translate();
        }
    }
}

Console/CheckCommand.php · install/packages/indian-rules/src/Console/CheckCommand.php

<?php

namespace Pathshala\IndianRules\Console;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Validator;
use Pathshala\IndianRules\Rules\Gstin;
use Pathshala\IndianRules\Rules\Ifsc;
use Pathshala\IndianRules\Rules\Pan;
use Pathshala\IndianRules\Rules\Pincode;

class CheckCommand extends Command
{
    protected $signature = 'indian-rules:check
        {rule : pan, gstin, ifsc or pincode}
        {value : the value to check}
        {--locale= : the language of the messages, such as hi}';

    protected $description = 'Check one value with one of the indian-rules rules';

    private const RULES = ['pan' => Pan::class, 'gstin' => Gstin::class, 'ifsc' => Ifsc::class, 'pincode' => Pincode::class];

    public function handle(): int
    {
        $rule = self::RULES[$this->argument('rule')] ?? null;

        if ($rule === null) {
            $this->error('Unknown rule: use pan, gstin, ifsc or pincode.');

            return self::INVALID;
        }

        if ($this->option('locale')) {
            $this->laravel->setLocale($this->option('locale'));
        }

        $validator = Validator::make(['value' => $this->argument('value')], ['value' => [new $rule()]]);

        if ($validator->passes()) {
            $this->line('valid');

            return self::SUCCESS;
        }

        foreach ($validator->errors()->all() as $message) {
            $this->line($message);
        }

        return self::FAILURE;
    }
}

config · install/packages/indian-rules/config/indian-rules.php

<?php

return [

    /*
     * Upper-case the value and drop spaces before checking, so a number typed as "abcpe 1234 f" is checked as
     * ABCPE1234F. Set it to false to check exactly what was sent.
     */
    'normalise' => true,

    /*
     * The fifteen-character tax number: which state codes the app accepts (null for every code) and whether the
     * last character is checked against the first fourteen.
     */
    'gstin' => [
        'states' => null,
        'check_character' => true,
    ],

];

lang/en · install/packages/indian-rules/lang/en/validation.php

<?php

return [
    'pan' => 'The :attribute field must be a 10-character PAN, such as ABCPE1234F.',
    'ifsc' => 'The :attribute field must be an 11-character IFSC, such as ABCD0123456.',
    'pincode' => 'The :attribute field must be a PIN code of six digits.',
    'gstin' => [
        'shape' => 'The :attribute field must be a 15-character number, such as 29ABCDE1234F1ZW.',
        'state' => 'The :attribute field starts with a state code this app does not accept.',
        'check' => 'The last character of :attribute does not match the other fourteen.',
    ],
];

lang/hi · install/packages/indian-rules/lang/hi/validation.php

<?php

return [
    'pan' => ':attribute दस वर्णों का PAN होना चाहिए, जैसे ABCPE1234F।',
    'ifsc' => ':attribute ग्यारह वर्णों का IFSC होना चाहिए, जैसे ABCD0123456।',
    'pincode' => ':attribute छह अंकों का पिन कोड होना चाहिए।',
    'gstin' => [
        'shape' => ':attribute 29ABCDE1234F1ZW जैसी 15 वर्णों की संख्या होनी चाहिए।',
        'state' => ':attribute ऐसे राज्य कोड से शुरू होता है जिसे यह ऐप स्वीकार नहीं करता।',
        'check' => ':attribute का अंतिम वर्ण बाकी चौदह वर्णों से मेल नहीं खाता।',
    ],
];