Introduce generators, update default alphabet, and remove prefix config and model location.

mitchdav · mitchdav · commit 27211adc023b · 2021-01-04T11:25:45.000+11:00
diff --git a/config/stripe_ids.php b/config/stripe_ids.php
@@ -4,18 +4,11 @@
 
     'hash_alphabet' => env(
         'STRIPE_IDS_HASH_ALPHABET',
-        '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+        '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
     ),
 
     'hash_length' => env('STRIPE_IDS_HASH_LENGTH', 16),
 
-    // The 'prefixes' key is optional, and is only required if you are using the StripeIds::findByStripeId() method to
-    // find generic models by their id.
-
-    'prefixes' => [
-
-        // 'ch_' => \App\Models\Charge::class,
-
-    ],
+    'generator' => \Mitchdav\StripeIds\Generators\TimestampFirstGenerator::class,
 
 ];
diff --git a/src/Generators/GeneratorInterface.php b/src/Generators/GeneratorInterface.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Mitchdav\StripeIds\Generators;
+
+interface GeneratorInterface
+{
+    public function generate(int $length): string;
+}
diff --git a/src/Generators/RandomBytesGenerator.php b/src/Generators/RandomBytesGenerator.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Mitchdav\StripeIds\Generators;
+
+class RandomBytesGenerator implements GeneratorInterface
+{
+    /**
+     * @param  int  $length
+     * @return string
+     * @throws \Exception
+     */
+    public function generate(int $length): string
+    {
+        return random_bytes($length);
+    }
+}
diff --git a/src/Generators/TimestampFirstGenerator.php b/src/Generators/TimestampFirstGenerator.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Mitchdav\StripeIds\Generators;
+
+use InvalidArgumentException;
+
+class TimestampFirstGenerator implements GeneratorInterface
+{
+    public const TIMESTAMP_BYTES = 6;
+
+    /**
+     * @param  int  $length
+     * @return string
+     * @throws \Exception
+     *
+     * @link https://github.com/ramsey/uuid
+     */
+    public function generate(int $length): string
+    {
+        if ($length < self::TIMESTAMP_BYTES || $length < 0) {
+            throw new InvalidArgumentException(
+                'Length must be a positive integer greater than or equal to '.self::TIMESTAMP_BYTES
+            );
+        }
+
+        $time = str_pad(
+            base_convert($this->timestamp(), 10, 16),
+            self::TIMESTAMP_BYTES * 2,
+            '0',
+            STR_PAD_LEFT
+        );
+
+        $hash = '';
+
+        if (self::TIMESTAMP_BYTES > 0 && $length > self::TIMESTAMP_BYTES) {
+            $hash = random_bytes($length - self::TIMESTAMP_BYTES);
+        }
+
+        return (string) hex2bin(
+            $time.str_pad(
+                bin2hex((string) $hash),
+                $length - self::TIMESTAMP_BYTES,
+                '0'
+            )
+        );
+    }
+
+    /**
+     * Returns current timestamp a string integer, precise to 0.00001 seconds
+     *
+     * @link https://github.com/ramsey/uuid
+     */
+    private function timestamp(): string
+    {
+        $time = explode(' ', microtime(false));
+
+        return $time[1].substr($time[0], 2, 5);
+    }
+}
diff --git a/src/HasStripeId.php b/src/HasStripeId.php
@@ -41,7 +41,7 @@ public function getStripeIdHashLength()
 
     public function getStripeIdPrefix()
     {
-        return $this->stripeIdPrefix ?? array_flip(config('stripe_ids.prefixes'))[get_class()] ?? null;
+        return $this->stripeIdPrefix ?? null;
     }
 
     public function getStripeId()
diff --git a/src/ServiceProvider.php b/src/ServiceProvider.php
@@ -2,6 +2,8 @@
 
 namespace Mitchdav\StripeIds;
 
+use Mitchdav\StripeIds\Generators\GeneratorInterface;
+
 class ServiceProvider extends \Illuminate\Support\ServiceProvider
 {
     public function register()
@@ -17,11 +19,15 @@ public function boot()
             __DIR__.'/../config/stripe_ids.php' => config_path('stripe_ids.php'),
         ], 'config');
 
+        $this->app->bind(GeneratorInterface::class, function ($app) {
+            return $this->app->make($app['config']['stripe_ids']['generator']);
+        });
+
         $this->app->singleton(StripeIds::class, function ($app) {
             return new StripeIds(
+                $this->app->make(GeneratorInterface::class),
                 $app['config']['stripe_ids']['hash_length'],
-                $app['config']['stripe_ids']['hash_alphabet'],
-                $app['config']['stripe_ids']['prefixes']
+                $app['config']['stripe_ids']['hash_alphabet']
             );
         });
     }
diff --git a/src/StripeIds.php b/src/StripeIds.php
@@ -2,12 +2,15 @@
 
 namespace Mitchdav\StripeIds;
 
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\ModelNotFoundException;
-use Illuminate\Support\Str;
+use Mitchdav\StripeIds\Generators\GeneratorInterface;
 
 class StripeIds
 {
+    /**
+     * @var GeneratorInterface
+     */
+    private $generator;
+
     /**
      * @var int
      */
@@ -18,16 +21,11 @@ class StripeIds
      */
     private $hashAlphabet;
 
-    /**
-     * @var array
-     */
-    private $prefixes;
-
-    public function __construct(int $hashLength, string $hashAlphabet, array $prefixes = [])
+    public function __construct(GeneratorInterface $generator, int $hashLength, string $hashAlphabet)
     {
+        $this->generator = $generator;
         $this->hashLength = $hashLength;
         $this->hashAlphabet = $hashAlphabet;
-        $this->prefixes = $prefixes;
     }
 
     public function id(string $prefix, $hashLength = null, $hashAlphabet = null)
@@ -41,30 +39,12 @@ public function hash($length = null, $alphabet = null)
         $hashAlphabet = $alphabet ?? $this->hashAlphabet;
         $hashAlphabetLength = strlen($hashAlphabet);
 
-        return collect(str_split(random_bytes($hashLength)))
+        $bytes = $this->generator->generate($hashLength);
+
+        return collect(str_split($bytes))
             ->map(function ($randomByte) use ($hashAlphabet, $hashAlphabetLength) {
                 return $hashAlphabet[ord($randomByte) % $hashAlphabetLength];
             })
             ->join('');
     }
-
-    public function findByStripeId($id, $prefixes = null)
-    {
-        /** @var string $model */
-        $model = collect($prefixes ?? $this->prefixes)
-            ->first(function ($model, $prefix) use ($id) {
-                return Str::startsWith($id, $prefix);
-            });
-
-        if ($model !== null) {
-            /** @var Model $instance */
-            $instance = app($model);
-
-            return $instance
-                ->newModelQuery()
-                ->whereKey($id);
-        } else {
-            throw new ModelNotFoundException();
-        }
-    }
 }
diff --git a/tests/FacadeTest.php b/tests/FacadeTest.php
@@ -17,7 +17,7 @@ public function it_can_generate_hashes()
     /** @test */
     public function it_can_generate_ids()
     {
-        $prefix = 'abc';
+        $prefix = 'abc_';
 
         $id = StripeIds::id($prefix);
 
diff --git a/tests/Generators/RandomBytesGeneratorTest.php b/tests/Generators/RandomBytesGeneratorTest.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace Mitchdav\StripeIds\Tests\Generators;
+
+use Illuminate\Support\Collection;
+use Mitchdav\StripeIds\Generators\RandomBytesGenerator;
+use Mitchdav\StripeIds\StripeIds;
+use Mitchdav\StripeIds\Tests\TestCase;
+
+class RandomBytesGeneratorTest extends TestCase
+{
+    const HASH_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+    const HASH_LENGTH = 16;
+
+    const ITERATIONS = 10000;
+
+    /** @test */
+    public function it_can_generate_hashes()
+    {
+        $stripeIds = new StripeIds(new RandomBytesGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $hash = $stripeIds->hash();
+
+        $this->assertEquals(1, preg_match('/^['.self::HASH_ALPHABET.']+$/', $hash));
+        $this->assertEquals(self::HASH_LENGTH, strlen($hash));
+    }
+
+    /** @test */
+    public function it_can_generate_ids()
+    {
+        $stripeIds = new StripeIds(new RandomBytesGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $prefix = 'abc_';
+
+        $id = $stripeIds->id($prefix);
+
+        $this->assertEquals(1, preg_match('/^'.$prefix.'['.self::HASH_ALPHABET.']+$/', $id));
+        $this->assertEquals(strlen($prefix) + self::HASH_LENGTH, strlen($id));
+    }
+
+    /** @test */
+    public function it_can_generate_unique_hashes()
+    {
+        $stripeIds = new StripeIds(new RandomBytesGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $hashes = Collection::times(self::ITERATIONS)
+            ->map(function () use ($stripeIds) {
+                return $stripeIds->hash();
+            });
+
+        $this->assertCount(self::ITERATIONS, $hashes->unique());
+    }
+
+    /** @test */
+    public function it_can_generate_unique_ids()
+    {
+        $stripeIds = new StripeIds(new RandomBytesGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $ids = Collection::times(self::ITERATIONS)
+            ->map(function () use ($stripeIds) {
+                return $stripeIds->id('abc');
+            });
+
+        $this->assertCount(self::ITERATIONS, $ids->unique());
+    }
+}
diff --git a/tests/Generators/TimestampFirstGeneratorTest.php b/tests/Generators/TimestampFirstGeneratorTest.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace Mitchdav\StripeIds\Tests\Generators;
+
+use Illuminate\Support\Collection;
+use Mitchdav\StripeIds\Generators\TimestampFirstGenerator;
+use Mitchdav\StripeIds\StripeIds;
+use Mitchdav\StripeIds\Tests\TestCase;
+
+class TimestampFirstGeneratorTest extends TestCase
+{
+    const HASH_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+    const HASH_LENGTH = 16;
+
+    const ITERATIONS = 10000;
+
+    /** @test */
+    public function it_can_generate_hashes()
+    {
+        $stripeIds = new StripeIds(new TimestampFirstGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $hash = $stripeIds->hash();
+
+        $this->assertEquals(1, preg_match('/^['.self::HASH_ALPHABET.']+$/', $hash));
+        $this->assertEquals(self::HASH_LENGTH, strlen($hash));
+    }
+
+    /** @test */
+    public function it_can_generate_ids()
+    {
+        $stripeIds = new StripeIds(new TimestampFirstGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $prefix = 'abc_';
+
+        $id = $stripeIds->id($prefix);
+
+        $this->assertEquals(1, preg_match('/^'.$prefix.'['.self::HASH_ALPHABET.']+$/', $id));
+        $this->assertEquals(strlen($prefix) + self::HASH_LENGTH, strlen($id));
+    }
+
+    /** @test */
+    public function it_can_generate_unique_hashes()
+    {
+        $stripeIds = new StripeIds(new TimestampFirstGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $hashes = Collection::times(self::ITERATIONS)
+            ->map(function () use ($stripeIds) {
+                return $stripeIds->hash();
+            });
+
+        $this->assertCount(self::ITERATIONS, $hashes->unique());
+    }
+
+    /** @test */
+    public function it_can_generate_unique_ids()
+    {
+        $stripeIds = new StripeIds(new TimestampFirstGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $ids = Collection::times(self::ITERATIONS)
+            ->map(function () use ($stripeIds) {
+                return $stripeIds->id('abc_');
+            });
+
+        $this->assertCount(self::ITERATIONS, $ids->unique());
+    }
+
+    /** @test */
+    public function it_can_generate_mostly_sequential_hashes()
+    {
+        $stripeIds = new StripeIds(new TimestampFirstGenerator(), self::HASH_LENGTH, self::HASH_ALPHABET);
+
+        $ids = Collection::times(self::ITERATIONS)
+            ->map(function () use ($stripeIds) {
+                return $stripeIds->hash();
+            });
+
+        $afterPrevious = $ids->map(function ($id, $index) use ($ids) {
+            if ($index === 0) {
+                return true;
+            }
+
+            // We subtract 2 from the TIMESTAMP_BYTES length because our StripeIds::hash method takes the modulo of
+            // each byte in the set of generated bytes against the size of the alphabet, which can cause the last bytes
+            // of the timestamp to not be sorted sequentially.
+            return strncmp($ids[$index - 1], $id, TimestampFirstGenerator::TIMESTAMP_BYTES - 2) <= 0;
+        });
+
+        $allAreAfterPrevious = $afterPrevious->every(function ($isAfterPrevious) {
+            return $isAfterPrevious === true;
+        });
+
+        $this->assertTrue($allAreAfterPrevious);
+    }
+}
diff --git a/tests/StripeIdsTest.php b/tests/StripeIdsTest.php

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public function getStripeIdHashLength()`
`41`	`41`
`42`	`42`	`public function getStripeIdPrefix()`
`43`	`43`	`{`
`44`		`- return $this->stripeIdPrefix ?? array_flip(config('stripe_ids.prefixes'))[get_class()] ?? null;`
	`44`	`+ return $this->stripeIdPrefix ?? null;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public function getStripeId()`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public function it_can_generate_hashes()`
`17`	`17`	`/** @test */`
`18`	`18`	`public function it_can_generate_ids()`
`19`	`19`	`{`
`20`		`- $prefix = 'abc';`
	`20`	`+ $prefix = 'abc_';`
`21`	`21`
`22`	`22`	`$id = StripeIds::id($prefix);`
`23`	`23`