├── .cursor
    └── rules
    │   └── cursor-rules-location.mdc
├── CHANGELOG.md
├── LICENSE.md
├── README.md
├── composer.json
├── config
    └── segment.php
├── laravel-segment-banner.svg
├── phpstan.neon.dist
├── phpunit.xml.dist.bak
└── src
    ├── Contracts
        ├── CanBeIdentifiedForSegment.php
        ├── CanBeSentToSegment.php
        ├── CanNotifyViaSegment.php
        ├── SegmentServiceContract.php
        └── ShouldBeAnonymouslyIdentified.php
    ├── Enums
        └── SegmentPayloadType.php
    ├── Exceptions
        ├── NotifiableCannotBeIdentifiedForSegmentException.php
        └── UnsupportedSegmentPayloadTypeException.php
    ├── Facades
        ├── Fakes
        │   └── SegmentFake.php
        └── Segment.php
    ├── LaravelSegmentServiceProvider.php
    ├── Middleware
        └── ApplySegmentGlobals.php
    ├── Notifications
        └── SegmentChannel.php
    ├── PendingUserSegment.php
    ├── SegmentService.php
    ├── SimpleSegmentAnonymousUser.php
    ├── SimpleSegmentEvent.php
    ├── SimpleSegmentIdentify.php
    ├── SimpleSegmentUser.php
    ├── Traits
        └── HasSegmentIdentityByKey.php
    └── ValueObjects
        └── SegmentPayload.php


/.cursor/rules/cursor-rules-location.mdc:
--------------------------------------------------------------------------------
 1 | ---
 2 | description: Rules for placing and organizing Cursor rule files in the repository.
 3 | globs: *.mdc
 4 | ---
 5 | # Cursor Rules Location
 6 | 
 7 | Rules for placing and organizing Cursor rule files in the repository.
 8 | 
 9 | <rule>
10 | name: cursor_rules_location
11 | description: Standards for placing Cursor rule files in the correct directory
12 | filters:
13 |   # Match any .mdc files
14 |   - type: file_extension
15 |     pattern: "\\.mdc$"
16 |   # Match files that look like Cursor rules
17 |   - type: content
18 |     pattern: "(?s)<rule>.*?</rule>"
19 |   # Match file creation events
20 |   - type: event
21 |     pattern: "file_create"
22 | 
23 | actions:
24 |   - type: reject
25 |     conditions:
26 |       - pattern: "^(?!\\.\\/\\.cursor\\/rules\\/.*\\.mdc$)"
27 |         message: "Cursor rule files (.mdc) must be placed in the .cursor/rules directory"
28 | 
29 |   - type: suggest
30 |     message: |
31 |       When creating Cursor rules:
32 | 
33 |       1. Always place rule files in PROJECT_ROOT/.cursor/rules/:
34 |          ```
35 |          .cursor/rules/
36 |          ├── your-rule-name.mdc
37 |          ├── another-rule.mdc
38 |          └── ...
39 |          ```
40 | 
41 |       2. Follow the naming convention:
42 |          - Use kebab-case for filenames
43 |          - Always use .mdc extension
44 |          - Make names descriptive of the rule's purpose
45 | 
46 |       3. Directory structure:
47 |          ```
48 |          PROJECT_ROOT/
49 |          ├── .cursor/
50 |          │   └── rules/
51 |          │       ├── your-rule-name.mdc
52 |          │       └── ...
53 |          └── ...
54 |          ```
55 | 
56 |       4. Never place rule files:
57 |          - In the project root
58 |          - In subdirectories outside .cursor/rules
59 |          - In any other location
60 | 
61 | examples:
62 |   - input: |
63 |       # Bad: Rule file in wrong location
64 |       rules/my-rule.mdc
65 |       my-rule.mdc
66 |       .rules/my-rule.mdc
67 | 
68 |       # Good: Rule file in correct location
69 |       .cursor/rules/my-rule.mdc
70 |     output: "Correctly placed Cursor rule file"
71 | 
72 | metadata:
73 |   priority: high
74 |   version: 1.0
75 | </rule>


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Changelog
2 | 
3 | All notable changes to `laravel-segment` will be documented in this file.
4 | 
5 | ## 1.0.0 - 202X-XX-XX
6 | 
7 | - initial release
8 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) SlashEquip <os@slashequip.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Laravel Segment
  2 | 
  3 | [![Latest Version on Packagist](https://img.shields.io/packagist/v/slashequip/laravel-segment.svg?style=flat-square)](https://packagist.org/packages/slashequip/laravel-segment)
  4 | [![tests](https://github.com/slashequip/laravel-segment/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/slashequip/laravel-segment/actions/workflows/run-tests.yml)
  5 | [![code style](https://github.com/slashequip/laravel-segment/actions/workflows/code-style.yml/badge.svg?branch=main)](https://github.com/slashequip/laravel-segment/actions/workflows/php-cs-fixer.yml)
  6 | [![psalm](https://github.com/slashequip/laravel-segment/actions/workflows/static-analysis.yml/badge.svg?branch=main)](https://github.com/slashequip/laravel-segment/actions/workflows/psalm.yml)
  7 | [![Total Downloads](https://img.shields.io/packagist/dt/slashequip/laravel-segment.svg?style=flat-square)](https://packagist.org/packages/slashequip/laravel-segment)
  8 | 
  9 | ![Laravel Segment Logo Banner](https://github.com/slashequip/laravel-segment/blob/main/laravel-segment-banner.svg?raw=true)
 10 | 
 11 | Laravel Segment is an opinionated, approach to integrating Segment into your Laravel application.
 12 | 
 13 | 
 14 | ## Installation
 15 | 
 16 | You can install the package via composer:
 17 | 
 18 | ```bash
 19 | composer require slashequip/laravel-segment
 20 | ```
 21 | 
 22 | 
 23 | You can publish the config file with:
 24 | ```bash
 25 | php artisan vendor:publish --provider="SlashEquip\LaravelSegment\LaravelSegmentServiceProvider"
 26 | ```
 27 | 
 28 | This is the contents of the published config file, which should be located at `config/segment.php`:
 29 | 
 30 | ```php
 31 | return [
 32 |     'enabled' => env('SEGMENT_ENABLED', true),
 33 | 
 34 |     /**
 35 |      * This is your Segment API write key. It can be
 36 |      * found under Source > Settings > Api Keys
 37 |      */
 38 |     'write_key' => env('SEGMENT_WRITE_KEY', null),
 39 | 
 40 |     /**
 41 |      * Should the Segment service defer all tracking
 42 |      * api calls until after the response, sending
 43 |      * everything using the bulk/batch api?
 44 |      */
 45 |     'defer' => env('SEGMENT_DEFER', false),
 46 | 
 47 |     /**
 48 |      * Should the Segment service be run in safe mode.
 49 |      * Safe mode will only report errors in sending
 50 |      * when safe mode is off exceptions are thrown
 51 |      */
 52 |     'safe_mode' => env('SEGMENT_SAFE_MODE', true),
 53 | ];
 54 | ```
 55 | 
 56 | ## Setting your write key
 57 | 
 58 | Your write key is the API key given to you by Segment which can be found under your PHP source settings; 
 59 | `https://app.segment.com/{your-workspace-name}/sources/{your-source-name}/settings/keys` in the Segment UI.
 60 | 
 61 | ## What is a Segment User
 62 | 
 63 | When we talk about a 'user' in the context of this package we mean any object that
 64 | implements the `SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment` contract
 65 | the package comes with a trait (and the interface) you can attach to your default
 66 | User model;
 67 | 
 68 | ```php
 69 | use Illuminate\Database\Eloquent\Model;
 70 | use SlashEquip\LaravelSegment\Traits\HasSegmentIdentityByKey;
 71 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 72 | 
 73 | class User extends Model implements CanBeIdentifiedForSegment
 74 | {
 75 |     use HasSegmentIdentityByKey;
 76 | }
 77 | ```
 78 | 
 79 | Using this trait will automagically use your users' primary key as the identifier
 80 | that is sent to Segment. Alternatively, you can implement your own instance of the
 81 | `public function getSegmentIdentifier(): string;` method on your User model and not
 82 | use the trait.
 83 | 
 84 | ### Globally identifying users
 85 | 
 86 | If you are sending Segment events in multiple places through your application and
 87 | through-out a request it might make sense to globally identify a user to make it
 88 | more convenient when making tracking calls.
 89 | 
 90 | ```php
 91 | use SlashEquip\LaravelSegment\Facades\Segment;
 92 | 
 93 | Segment::setGlobalUser($user);
 94 | ```
 95 | 
 96 | ### Globally setting context
 97 | 
 98 | Segment allows you to send [context](https://segment.com/docs/connections/spec/common/#context)
 99 | with your tracking events too, you can set a global context that applies to all tracking events.
100 | 
101 | ```php
102 | use SlashEquip\LaravelSegment\Facades\Segment;
103 | 
104 | Segment::setGlobalContext([
105 |     'ip' => '127.0.0.1',
106 |     'locale' => 'en-US',
107 |     'screen' => [
108 |         'height' => 1080,
109 |         'width' => 1920,
110 |     ],
111 | ]);
112 | ```
113 | 
114 | ### Here have some convenience
115 | 
116 | Laravel Segment ships with a middleware that you can apply in your HTTP Kernal that will handle
117 | the setting of the global user and some sensible global context too. It should be simple to extend
118 | this middleware and adjust for your needs if you want to add to the default context provided.
119 | 
120 | ```php
121 |     'api' => [
122 |         // ... other middleware
123 |         SlashEquip\LaravelSegment\Middleware\ApplySegmentGlobals::class
124 |     ],
125 | ```
126 | 
127 | ## Usage
128 | 
129 | ### For tracking events
130 | ```php
131 | use SlashEquip\LaravelSegment\Facades\Segment;
132 | 
133 | Segment::forUser($user)->track('User Signed Up', [
134 |     'source' => 'Product Hunt',
135 | ]);
136 | 
137 | // If you have set a global user you can
138 | // use the simpler provided syntax.
139 | Segment::track('User Signed Up', [
140 |     'source' => 'Product Hunt',
141 | ]);
142 | 
143 | // If you have defer enabled in the config
144 | // you can still track an event immediately using trackNow.
145 | Segment::trackNow('User Signed Up', [
146 |     'source' => 'Product Hunt',
147 | ]);
148 | ```
149 | 
150 | ### For identifying users
151 | ```php
152 | use SlashEquip\LaravelSegment\Facades\Segment;
153 | 
154 | Segment::forUser($user)->identify([
155 |     'last_logged_in' => '2021-03-24 20:05:30',
156 |     'latest_subscription_amount' => '$24.60',
157 | ]);
158 | 
159 | // If you have set a global user you can
160 | // use the simpler provided syntax.
161 | Segment::identify([
162 |     'last_logged_in' => '2021-03-24 20:05:30',
163 |     'latest_subscription_amount' => '$24.60',
164 | ]);
165 | 
166 | // If you have defer enabled in the config
167 | // you can still identify a user immediately using identifyNow.
168 | Segment::identifyNow([
169 |     'source' => 'Product Hunt',
170 | ]);
171 | ```
172 | 
173 | ### Anonymous users
174 | 
175 | Segment allows you to track events for users that are not yet users in your system, they call these anonymous users.
176 | 
177 | To track events for anonymous users you can use apply the `ShouldBeAnonymouslyIdentified` interface to any `CanBeIdentifiedForSegment` implementation.
178 | 
179 | ```php
180 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
181 | use SlashEquip\LaravelSegment\Contracts\ShouldBeAnonymouslyIdentified;
182 | 
183 | class SegmentAnonymousTestUser implements CanBeIdentifiedForSegment, ShouldBeAnonymouslyIdentified
184 | {
185 | }
186 | ```
187 | 
188 | For convenience, the package comes with a `SimpleSegmentAnonymousUser` class that implements the `ShouldBeAnonymouslyIdentified` interface.
189 | 
190 | ```php
191 | use SlashEquip\LaravelSegment\SimpleSegmentAnonymousUser;
192 | 
193 | Segment::forUser(new SimpleSegmentAnonymousUser('123'))->track('Kitchen sink used');
194 | ```
195 | 
196 | ### Laravel Notifications
197 | This package includes an out-of-the-box notification channel, to allow you to use Laravel's built-in notification
198 | feature. To send Segment events to users as notifications, generate your notification as normal;
199 | 
200 | ```
201 | php artisan make:notification UserSubscribed
202 | ```
203 | 
204 | You must ensure your notification implements the `CanNotifyViaSegment` interface, and add the required `toSegment`
205 | method. Then you can configure the `via` method to include the `SegmentChannel` class.
206 | 
207 | You can then adjust the `toSegment` method to return the event you'd like. 
208 | 
209 | ```php
210 | use Illuminate\Notifications\Notification;
211 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
212 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
213 | use SlashEquip\LaravelSegment\Contracts\CanNotifyViaSegment;
214 | use SlashEquip\LaravelSegment\Notifications\SegmentChannel;
215 | use SlashEquip\LaravelSegment\SimpleSegmentEvent;
216 | 
217 | class UserSubscribed extends Notification implements CanNotifyViaSegment
218 | {
219 |     public function __construct(
220 |     ) {
221 |     }
222 | 
223 |     public function via(object $notifiable): array
224 |     {
225 |         return [SegmentChannel::class];
226 |     }
227 | 
228 |     public function toSegment(CanBeIdentifiedForSegment $notifiable): CanBeSentToSegment
229 |     {
230 |         return new SimpleSegmentEvent(
231 |             $notifiable,
232 |             'User Subscribed',
233 |             [
234 |                 'plan' => 'basic',
235 |                 'team_name' => 'Funky chickens',
236 |             ],
237 |         );
238 |     }
239 | }
240 | ```
241 | 
242 | ## Misc
243 | 
244 | ### Deferring
245 | When you start to fire many events in your application, even 2-3 per request it can be hyper-beneficial to
246 | turn on deferring (see config). When deferring is enabled, the service will store all of your tracking events triggered
247 | through-out the request or process and then send them in batch after your application has responded to your user. This
248 | happens during the Laravel termination.
249 | 
250 | ### Safe mode
251 | By default, safe-mode is turned on. When safe-mode is active it will swallow any exceptions thrown when making the HTTP
252 | request to Segment and report them automatically to the exception handler, allow your app to continue running. When
253 | disabled then the exception will be thrown.
254 | 
255 | ## Testing
256 | 
257 | ```bash
258 | ./vendor/bin/pest
259 | ```
260 | 
261 | ### Using `Segment::fake()` in tests
262 | 
263 | To prevent real HTTP requests when running your own test suite, call
264 | `Segment::fake()` before executing the code under test. This swaps the
265 | Segment service with a fake that records events and identity calls. You can
266 | then use assertion helpers to verify what was sent:
267 | 
268 | ```php
269 | use SlashEquip\LaravelSegment\Facades\Segment;
270 | 
271 | Segment::fake();
272 | 
273 | // Code that should trigger Segment events
274 | 
275 | Segment::assertTracked('User Signed Up');
276 | Segment::assertIdentified();
277 | ```
278 | 
279 | ## Changelog
280 | 
281 | Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.
282 | 
283 | ## Contributing
284 | 
285 | Please see [CONTRIBUTING](.github/CONTRIBUTING.md) for details.
286 | 
287 | ## Security Vulnerabilities
288 | 
289 | Please review [our security policy](../../security/policy) on how to report security vulnerabilities.
290 | 
291 | ## Credits
292 | 
293 | - [SlashEquip](https://github.com/slashequip)
294 | - [All Contributors](../../contributors)
295 | 
296 | ## License
297 | 
298 | The MIT License (MIT). Please see [License File](LICENSE.md) for more information.
299 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "slashequip/laravel-segment",
 3 |     "description": "Laravel Segment is an opinionated, approach to integrating Segment into your Laravel application.",
 4 |     "keywords": [
 5 |         "laravel-segment"
 6 |     ],
 7 |     "homepage": "https://github.com/slashequip/laravel-segment",
 8 |     "license": "MIT",
 9 |     "authors": [
10 |         {
11 |             "name": "Sam Jones",
12 |             "email": "sam@slashequip.com",
13 |             "role": "Developer"
14 |         }
15 |     ],
16 |     "require": {
17 |         "php": "^8.2",
18 |         "guzzlehttp/guzzle": "^7.8",
19 |         "illuminate/contracts": "^11.0|^12.0"
20 |     },
21 |     "require-dev": {
22 |         "larastan/larastan": "^3.3",
23 |         "laravel/pint": "^1.18",
24 |         "mockery/mockery": "^1.6",
25 |         "orchestra/testbench": "^9.0|^10.0",
26 |         "pestphp/pest": "^3.7"
27 |     },
28 |     "autoload": {
29 |         "psr-4": {
30 |             "SlashEquip\\LaravelSegment\\": "src"
31 |         }
32 |     },
33 |     "autoload-dev": {
34 |         "psr-4": {
35 |             "SlashEquip\\LaravelSegment\\Tests\\": "tests"
36 |         }
37 |     },
38 |     "scripts": {
39 |         "analyse": "vendor/bin/phpstan",
40 |         "format": "vendor/bin/pint",
41 |         "test": "vendor/bin/pest"
42 |     },
43 |     "config": {
44 |         "sort-packages": true,
45 |         "allow-plugins": {
46 |             "pestphp/pest-plugin": true
47 |         }
48 |     },
49 |     "extra": {
50 |         "laravel": {
51 |             "providers": [
52 |                 "SlashEquip\\LaravelSegment\\LaravelSegmentServiceProvider"
53 |             ],
54 |             "aliases": {
55 |                 "Segment": "SlashEquip\\LaravelSegment\\Facades\\Segment"
56 |             }
57 |         }
58 |     },
59 |     "minimum-stability": "dev",
60 |     "prefer-stable": true
61 | }
62 | 


--------------------------------------------------------------------------------
/config/segment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'enabled' => env('SEGMENT_ENABLED', true),
 5 | 
 6 |     /**
 7 |      * This is your Segment API write key. It can be
 8 |      * found under Source > Settings > Api Keys
 9 |      */
10 |     'write_key' => env('SEGMENT_WRITE_KEY', null),
11 | 
12 |     /**
13 |      * Should the Segment service defer all tracking
14 |      * api calls until after the response, sending
15 |      * everything using the bulk/batch api?
16 |      */
17 |     'defer' => env('SEGMENT_DEFER', false),
18 | 
19 |     /**
20 |      * Should the Segment service be run in safe mode.
21 |      * Safe mode will only report errors in sending
22 |      * when safe mode is off exceptions are thrown
23 |      */
24 |     'safe_mode' => env('SEGMENT_SAFE_MODE', true),
25 | ];
26 | 


--------------------------------------------------------------------------------
/laravel-segment-banner.svg:
--------------------------------------------------------------------------------
 1 | <svg width="2400" height="350" viewBox="0 0 2400 350" fill="none" xmlns="http://www.w3.org/2000/svg">
 2 | <rect width="2400" height="350" fill="#48B882"/>
 3 | <path d="M196 247L168 231L112 263M196 247L140 279M196 247V279L140 311M140 279L112 263M140 279V311M112 263V295L140 311" stroke="white" stroke-width="4" stroke-linejoin="round"/>
 4 | <path d="M140 55L168 39L196 55M140 55L168 71M140 55V87L168 103M168 71L196 55M168 71V103M196 55V87L168 103" stroke="white" stroke-width="4" stroke-linejoin="round"/>
 5 | <path d="M140 151L196 183L168 199V231L112 199V167L140 151Z" fill="#B8DFC8"/>
 6 | <path d="M140 151L196 183M168 199L112 167M168 231L112 199" stroke="white" stroke-width="4" stroke-linecap="round" stroke-dasharray="10 10"/>
 7 | <path d="M84 119L140 87L168 103M84 119L112 135M84 119V183L112 199M168 103L112 135M168 103V135L140 151V183L112 199M112 135V199" stroke="white" stroke-width="4" stroke-linejoin="round"/>
 8 | <path d="M168 199L196 183L224 199M168 199L196 215M168 199V231L196 247M196 215L224 199M196 215V247M224 199V231L196 247" stroke="white" stroke-width="4" stroke-linejoin="round"/>
 9 | <path d="M269.976 90.736H277.392V135.808H302.304V142H269.976V90.736ZM342.106 105.712V142H334.906V135.808C333.85 137.968 332.266 139.624 330.154 140.776C328.09 141.928 325.666 142.504 322.882 142.504C319.666 142.504 316.834 141.736 314.386 140.2C311.986 138.664 310.114 136.504 308.77 133.72C307.426 130.888 306.754 127.6 306.754 123.856C306.754 120.112 307.426 116.8 308.77 113.92C310.162 111.04 312.082 108.808 314.53 107.224C316.978 105.64 319.762 104.848 322.882 104.848C325.666 104.848 328.09 105.448 330.154 106.648C332.218 107.8 333.802 109.456 334.906 111.616V105.712H342.106ZM324.61 136.744C327.874 136.744 330.394 135.616 332.17 133.36C333.994 131.056 334.906 127.84 334.906 123.712C334.906 119.536 333.994 116.32 332.17 114.064C330.394 111.808 327.85 110.68 324.538 110.68C321.274 110.68 318.706 111.856 316.834 114.208C315.01 116.512 314.098 119.728 314.098 123.856C314.098 127.936 315.01 131.104 316.834 133.36C318.706 135.616 321.298 136.744 324.61 136.744ZM370.861 104.848C371.965 104.848 373.117 105.016 374.317 105.352L374.173 111.976C372.877 111.496 371.461 111.256 369.925 111.256C366.613 111.256 364.117 112.264 362.437 114.28C360.805 116.248 359.989 118.744 359.989 121.768V142H352.789V115.936C352.789 112.144 352.597 108.736 352.213 105.712H358.981L359.629 112.264C360.589 109.864 362.077 108.04 364.093 106.792C366.109 105.496 368.365 104.848 370.861 104.848ZM412.348 105.712V142H405.148V135.808C404.092 137.968 402.508 139.624 400.396 140.776C398.332 141.928 395.908 142.504 393.124 142.504C389.908 142.504 387.076 141.736 384.628 140.2C382.228 138.664 380.356 136.504 379.012 133.72C377.668 130.888 376.996 127.6 376.996 123.856C376.996 120.112 377.668 116.8 379.012 113.92C380.404 111.04 382.324 108.808 384.772 107.224C387.22 105.64 390.004 104.848 393.124 104.848C395.908 104.848 398.332 105.448 400.396 106.648C402.46 107.8 404.044 109.456 405.148 111.616V105.712H412.348ZM394.852 136.744C398.116 136.744 400.636 135.616 402.412 133.36C404.236 131.056 405.148 127.84 405.148 123.712C405.148 119.536 404.236 116.32 402.412 114.064C400.636 111.808 398.092 110.68 394.78 110.68C391.516 110.68 388.948 111.856 387.076 114.208C385.252 116.512 384.34 119.728 384.34 123.856C384.34 127.936 385.252 131.104 387.076 133.36C388.948 135.616 391.54 136.744 394.852 136.744ZM456.007 105.784L440.239 142H433.687L418.063 105.784H425.767L437.143 133.792L448.735 105.784H456.007ZM492.101 124H466.181C466.421 132.496 470.285 136.744 477.773 136.744C481.949 136.744 485.765 135.376 489.221 132.64L491.453 137.824C489.821 139.264 487.733 140.416 485.189 141.28C482.693 142.096 480.173 142.504 477.629 142.504C471.821 142.504 467.261 140.848 463.949 137.536C460.637 134.176 458.981 129.592 458.981 123.784C458.981 120.088 459.701 116.8 461.141 113.92C462.629 111.04 464.693 108.808 467.333 107.224C469.973 105.64 472.973 104.848 476.333 104.848C481.229 104.848 485.069 106.432 487.853 109.6C490.685 112.768 492.101 117.16 492.101 122.776V124ZM476.477 110.248C473.741 110.248 471.509 111.064 469.781 112.696C468.053 114.328 466.949 116.656 466.469 119.68H485.693C485.405 116.608 484.469 114.28 482.885 112.696C481.301 111.064 479.165 110.248 476.477 110.248ZM500.445 89.008H507.645V142H500.445V89.008Z" fill="#CDECDA"/>
10 | <path d="M301.92 255.96C295.28 255.96 289.2 255.08 283.68 253.32C278.24 251.56 273.52 248.92 269.52 245.4L273.96 236.28C278.12 239.64 282.44 242.08 286.92 243.6C291.4 245.12 296.44 245.88 302.04 245.88C308.44 245.88 313.4 244.68 316.92 242.28C320.44 239.88 322.2 236.48 322.2 232.08C322.2 228.4 320.56 225.64 317.28 223.8C314 221.88 308.8 220.12 301.68 218.52C294.88 217.08 289.32 215.44 285 213.6C280.68 211.68 277.28 209.16 274.8 206.04C272.32 202.84 271.08 198.76 271.08 193.8C271.08 188.84 272.4 184.48 275.04 180.72C277.68 176.88 281.4 173.92 286.2 171.84C291.08 169.68 296.68 168.6 303 168.6C309 168.6 314.6 169.52 319.8 171.36C325.08 173.2 329.48 175.8 333 179.16L328.56 188.28C324.64 185 320.6 182.6 316.44 181.08C312.28 179.48 307.84 178.68 303.12 178.68C296.96 178.68 292.12 180 288.6 182.64C285.08 185.2 283.32 188.72 283.32 193.2C283.32 197.04 284.84 199.96 287.88 201.96C291 203.96 295.96 205.76 302.76 207.36C309.88 208.96 315.64 210.64 320.04 212.4C324.44 214.16 327.96 216.56 330.6 219.6C333.24 222.64 334.56 226.56 334.56 231.36C334.56 236.32 333.24 240.64 330.6 244.32C327.96 248 324.16 250.88 319.2 252.96C314.32 254.96 308.56 255.96 301.92 255.96ZM400.418 225H357.218C357.618 239.16 364.058 246.24 376.538 246.24C383.498 246.24 389.858 243.96 395.618 239.4L399.338 248.04C396.618 250.44 393.138 252.36 388.898 253.8C384.738 255.16 380.538 255.84 376.298 255.84C366.618 255.84 359.018 253.08 353.498 247.56C347.978 241.96 345.218 234.32 345.218 224.64C345.218 218.48 346.418 213 348.818 208.2C351.298 203.4 354.738 199.68 359.138 197.04C363.538 194.4 368.538 193.08 374.138 193.08C382.298 193.08 388.698 195.72 393.338 201C398.058 206.28 400.418 213.6 400.418 222.96V225ZM374.378 202.08C369.818 202.08 366.098 203.44 363.218 206.16C360.338 208.88 358.498 212.76 357.698 217.8H389.738C389.258 212.68 387.698 208.8 385.058 206.16C382.418 203.44 378.858 202.08 374.378 202.08ZM470.125 194.52V253.92C470.125 263.12 467.685 270.04 462.805 274.68C458.005 279.4 450.845 281.76 441.325 281.76C432.125 281.76 424.085 279.76 417.205 275.76L419.245 266.28C423.005 268.28 426.605 269.76 430.045 270.72C433.565 271.68 437.285 272.16 441.205 272.16C452.485 272.16 458.125 266.4 458.125 254.88V241.8C456.285 245.32 453.605 248.12 450.085 250.2C446.565 252.2 442.485 253.2 437.845 253.2C432.565 253.2 427.845 251.96 423.685 249.48C419.605 247 416.405 243.48 414.085 238.92C411.845 234.36 410.725 229.12 410.725 223.2C410.725 217.28 411.845 212.04 414.085 207.48C416.405 202.92 419.605 199.4 423.685 196.92C427.845 194.36 432.565 193.08 437.845 193.08C442.485 193.08 446.565 194.08 450.085 196.08C453.605 198 456.285 200.76 458.125 204.36V194.52H470.125ZM440.605 243.48C446.045 243.48 450.325 241.68 453.445 238.08C456.565 234.48 458.125 229.52 458.125 223.2C458.125 216.88 456.565 211.92 453.445 208.32C450.405 204.64 446.125 202.8 440.605 202.8C435.165 202.8 430.845 204.64 427.645 208.32C424.525 211.92 422.965 216.88 422.965 223.2C422.965 229.44 424.525 234.4 427.645 238.08C430.845 241.68 435.165 243.48 440.605 243.48ZM556.919 193.08C570.359 193.08 577.079 201.16 577.079 217.32V255H564.959V217.92C564.959 212.72 564.039 208.92 562.199 206.52C560.439 204.12 557.559 202.92 553.559 202.92C548.919 202.92 545.239 204.52 542.519 207.72C539.879 210.92 538.559 215.28 538.559 220.8V255H526.439V217.92C526.439 212.72 525.519 208.92 523.679 206.52C521.919 204.12 519.039 202.92 515.039 202.92C510.399 202.92 506.719 204.52 503.999 207.72C501.279 210.92 499.919 215.28 499.919 220.8V255H487.919V211.56C487.919 205.24 487.599 199.56 486.959 194.52H498.239L499.319 204.6C501.079 200.92 503.599 198.08 506.879 196.08C510.159 194.08 513.999 193.08 518.399 193.08C527.759 193.08 533.879 196.96 536.759 204.72C538.599 201.12 541.279 198.28 544.799 196.2C548.399 194.12 552.439 193.08 556.919 193.08ZM646.043 225H602.843C603.243 239.16 609.683 246.24 622.163 246.24C629.123 246.24 635.483 243.96 641.243 239.4L644.963 248.04C642.243 250.44 638.763 252.36 634.523 253.8C630.363 255.16 626.163 255.84 621.923 255.84C612.243 255.84 604.643 253.08 599.123 247.56C593.603 241.96 590.843 234.32 590.843 224.64C590.843 218.48 592.043 213 594.443 208.2C596.923 203.4 600.363 199.68 604.763 197.04C609.163 194.4 614.163 193.08 619.763 193.08C627.923 193.08 634.323 195.72 638.963 201C643.683 206.28 646.043 213.6 646.043 222.96V225ZM620.003 202.08C615.443 202.08 611.723 203.44 608.843 206.16C605.963 208.88 604.123 212.76 603.323 217.8H635.363C634.883 212.68 633.323 208.8 630.683 206.16C628.043 203.44 624.483 202.08 620.003 202.08ZM692.11 193.08C706.59 193.08 713.83 201.16 713.83 217.32V255H701.71V218.04C701.71 212.76 700.67 208.92 698.59 206.52C696.59 204.12 693.35 202.92 688.87 202.92C683.75 202.92 679.63 204.52 676.51 207.72C673.47 210.92 671.95 215.2 671.95 220.56V255H659.95V211.56C659.95 205.24 659.63 199.56 658.99 194.52H670.27L671.35 204.96C673.27 201.12 676.03 198.2 679.63 196.2C683.31 194.12 687.47 193.08 692.11 193.08ZM746.803 203.88V234.24C746.803 238.4 747.683 241.36 749.443 243.12C751.283 244.8 753.803 245.64 757.003 245.64C759.083 245.64 761.203 245.32 763.363 244.68V254.52C760.723 255.4 757.723 255.84 754.363 255.84C748.123 255.84 743.283 254.08 739.843 250.56C736.403 247.04 734.683 241.92 734.683 235.2V203.88H722.923V194.52H734.683V179.4L746.803 175.2V194.52H763.483V203.88H746.803Z" fill="white"/>
11 | </svg>
12 | 


--------------------------------------------------------------------------------
/phpstan.neon.dist:
--------------------------------------------------------------------------------
 1 | includes:
 2 |     - ./vendor/larastan/larastan/extension.neon
 3 | 
 4 | parameters:
 5 | 
 6 |     paths:
 7 |         - src/
 8 | 
 9 |     # Level 9 is the highest level
10 |     level: 6
11 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist.bak:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit
 3 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |     xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 5 |     backupGlobals="false"
 6 |     backupStaticAttributes="false"
 7 |     bootstrap="vendor/autoload.php"
 8 |     colors="true"
 9 |     convertErrorsToExceptions="true"
10 |     convertNoticesToExceptions="true"
11 |     convertWarningsToExceptions="true"
12 |     processIsolation="false"
13 |     stopOnFailure="false"
14 |     executionOrder="random"
15 |     failOnWarning="true"
16 |     failOnRisky="true"
17 |     failOnEmptyTestSuite="true"
18 |     beStrictAboutOutputDuringTests="true"
19 |     verbose="true"
20 | >
21 |     <testsuites>
22 |         <testsuite name="Laravel Segment Test Suite">
23 |             <directory>tests</directory>
24 |         </testsuite>
25 |     </testsuites>
26 |     <coverage>
27 |         <include>
28 |             <directory suffix=".php">./src</directory>
29 |         </include>
30 |         <report>
31 |             <html outputDirectory="build/coverage"/>
32 |             <text outputFile="build/coverage.txt"/>
33 |             <clover outputFile="build/logs/clover.xml"/>
34 |         </report>
35 |     </coverage>
36 |     <logging>
37 |         <junit outputFile="build/report.junit.xml"/>
38 |     </logging>
39 | </phpunit>
40 | 


--------------------------------------------------------------------------------
/src/Contracts/CanBeIdentifiedForSegment.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace SlashEquip\LaravelSegment\Contracts;
4 | 
5 | interface CanBeIdentifiedForSegment
6 | {
7 |     public function getSegmentIdentifier(): string;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Contracts/CanBeSentToSegment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Contracts;
 4 | 
 5 | use SlashEquip\LaravelSegment\ValueObjects\SegmentPayload;
 6 | 
 7 | interface CanBeSentToSegment
 8 | {
 9 |     public function toSegment(): SegmentPayload;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Contracts/CanNotifyViaSegment.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace SlashEquip\LaravelSegment\Contracts;
4 | 
5 | interface CanNotifyViaSegment
6 | {
7 |     public function toSegment(CanBeIdentifiedForSegment $notifiable): CanBeSentToSegment;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Contracts/SegmentServiceContract.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Contracts;
 4 | 
 5 | use SlashEquip\LaravelSegment\PendingUserSegment;
 6 | 
 7 | interface SegmentServiceContract
 8 | {
 9 |     public function setGlobalUser(CanBeIdentifiedForSegment $globalUser): void;
10 | 
11 |     /**
12 |      * @param  array<string, mixed>  $globalContext
13 |      */
14 |     public function setGlobalContext(array $globalContext): void;
15 | 
16 |     /**
17 |      * @param  array<string, mixed>  $eventData
18 |      */
19 |     public function track(string $event, ?array $eventData = null): void;
20 | 
21 |     /**
22 |      * @param  array<string, mixed>  $eventData
23 |      */
24 |     public function trackNow(string $event, ?array $eventData = null): void;
25 | 
26 |     /**
27 |      * @param  array<string, mixed>  $identifyData
28 |      */
29 |     public function identify(?array $identifyData = null): void;
30 | 
31 |     /**
32 |      * @param  array<string, mixed>  $identifyData
33 |      */
34 |     public function identifyNow(?array $identifyData = null): void;
35 | 
36 |     public function forUser(CanBeIdentifiedForSegment $user): PendingUserSegment;
37 | 
38 |     public function push(CanBeSentToSegment $segment): void;
39 | 
40 |     public function terminate(): void;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Contracts/ShouldBeAnonymouslyIdentified.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace SlashEquip\LaravelSegment\Contracts;
4 | 
5 | interface ShouldBeAnonymouslyIdentified {}
6 | 


--------------------------------------------------------------------------------
/src/Enums/SegmentPayloadType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Enums;
 4 | 
 5 | enum SegmentPayloadType: string
 6 | {
 7 |     case Track = 'track';
 8 |     case Identify = 'identify';
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exceptions/NotifiableCannotBeIdentifiedForSegmentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Exceptions;
 4 | 
 5 | use RuntimeException;
 6 | 
 7 | class NotifiableCannotBeIdentifiedForSegmentException extends RuntimeException
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Exceptions/UnsupportedSegmentPayloadTypeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Exceptions;
 4 | 
 5 | use RuntimeException;
 6 | 
 7 | class UnsupportedSegmentPayloadTypeException extends RuntimeException
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Facades/Fakes/SegmentFake.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SlashEquip\LaravelSegment\Facades\Fakes;
  4 | 
  5 | use Closure;
  6 | use Illuminate\Support\Collection;
  7 | use PHPUnit\Framework\Assert as PHPUnit;
  8 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
  9 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
 10 | use SlashEquip\LaravelSegment\Contracts\SegmentServiceContract;
 11 | use SlashEquip\LaravelSegment\PendingUserSegment;
 12 | use SlashEquip\LaravelSegment\SimpleSegmentEvent;
 13 | use SlashEquip\LaravelSegment\SimpleSegmentIdentify;
 14 | 
 15 | class SegmentFake implements SegmentServiceContract
 16 | {
 17 |     private CanBeIdentifiedForSegment $user;
 18 | 
 19 |     /** @var array<string, mixed> */
 20 |     private array $context = [];
 21 | 
 22 |     /** @var array<int, SimpleSegmentEvent> */
 23 |     private array $events = [];
 24 | 
 25 |     /** @var array<int, SimpleSegmentIdentify> */
 26 |     private array $identities = [];
 27 | 
 28 |     public function setGlobalUser(CanBeIdentifiedForSegment $globalUser): void
 29 |     {
 30 |         $this->user = $globalUser;
 31 |     }
 32 | 
 33 |     /**
 34 |      * @param  array<string, mixed>  $globalContext
 35 |      */
 36 |     public function setGlobalContext(array $globalContext): void
 37 |     {
 38 |         $this->context = $globalContext;
 39 |     }
 40 | 
 41 |     /**
 42 |      * @param  array<string, mixed>  $identifyData
 43 |      */
 44 |     public function identify(?array $identifyData = null): void
 45 |     {
 46 |         $this->identities[] = new SimpleSegmentIdentify(
 47 |             $this->user,
 48 |             $identifyData
 49 |         );
 50 |     }
 51 | 
 52 |     /**
 53 |      * @param  array<string, mixed>  $identifyData
 54 |      */
 55 |     public function identifyNow(?array $identifyData = null): void
 56 |     {
 57 |         $this->identities[] = new SimpleSegmentIdentify(
 58 |             $this->user,
 59 |             $identifyData
 60 |         );
 61 |     }
 62 | 
 63 |     /**
 64 |      * @param  array<string, mixed>  $eventData
 65 |      */
 66 |     public function track(string $event, ?array $eventData = null): void
 67 |     {
 68 |         $this->events[] = new SimpleSegmentEvent(
 69 |             $this->user,
 70 |             $event,
 71 |             $eventData
 72 |         );
 73 |     }
 74 | 
 75 |     /**
 76 |      * @param  array<string, mixed>  $eventData
 77 |      */
 78 |     public function trackNow(string $event, ?array $eventData = null): void
 79 |     {
 80 |         $this->events[] = new SimpleSegmentEvent(
 81 |             $this->user,
 82 |             $event,
 83 |             $eventData
 84 |         );
 85 |     }
 86 | 
 87 |     public function forUser(CanBeIdentifiedForSegment $user): PendingUserSegment
 88 |     {
 89 |         $this->user = $user;
 90 | 
 91 |         return new PendingUserSegment($this, $user);
 92 |     }
 93 | 
 94 |     public function push(CanBeSentToSegment $segment): void
 95 |     {
 96 |         if ($segment instanceof SimpleSegmentIdentify) {
 97 |             $this->identities[] = $segment;
 98 |         }
 99 | 
100 |         if ($segment instanceof SimpleSegmentEvent) {
101 |             $this->events[] = $segment;
102 |         }
103 |     }
104 | 
105 |     public function terminate(): void {}
106 | 
107 |     public function assertIdentified(Closure|int|null $callback = null): void
108 |     {
109 |         if (is_numeric($callback)) {
110 |             $this->assertIdentifiedTimes($callback);
111 | 
112 |             return;
113 |         }
114 | 
115 |         PHPUnit::assertTrue(
116 |             $this->identities($callback)->count() > 0,
117 |             'The expected identities were not called.'
118 |         );
119 |     }
120 | 
121 |     public function assertIdentifiedTimes(int $times = 1): void
122 |     {
123 |         $count = collect($this->identities)->count();
124 | 
125 |         PHPUnit::assertSame(
126 |             $times,
127 |             $count,
128 |             "The identity was called {$count} times instead of {$times} times."
129 |         );
130 |     }
131 | 
132 |     public function assertNotIdentified(?Closure $callback = null): void
133 |     {
134 |         PHPUnit::assertCount(
135 |             0,
136 |             $this->identities($callback),
137 |             'The unexpected identity was called.'
138 |         );
139 |     }
140 | 
141 |     public function assertNothingIdentified(): void
142 |     {
143 |         $identities = collect($this->identities);
144 | 
145 |         PHPUnit::assertEmpty(
146 |             $identities->all(),
147 |             $identities->count().' events were found unexpectedly.'
148 |         );
149 |     }
150 | 
151 |     public function assertTracked(Closure|int|null $callback = null): void
152 |     {
153 |         if (is_numeric($callback)) {
154 |             $this->assertTrackedTimes($callback);
155 | 
156 |             return;
157 |         }
158 | 
159 |         PHPUnit::assertTrue(
160 |             $this->events($callback)->count() > 0,
161 |             'The expected events were not called.'
162 |         );
163 |     }
164 | 
165 |     public function assertTrackedTimes(int $times = 1): void
166 |     {
167 |         $count = collect($this->events)->count();
168 | 
169 |         PHPUnit::assertSame(
170 |             $times,
171 |             $count,
172 |             "The event called {$count} times instead of {$times} times."
173 |         );
174 |     }
175 | 
176 |     public function assertEventTracked(
177 |         string $event,
178 |         Closure|int|null $callback = null
179 |     ): void {
180 |         PHPUnit::assertTrue(
181 |             $this->events($callback, $event)->count() > 0,
182 |             'The expected events were not called.'
183 |         );
184 |     }
185 | 
186 |     public function assertNotTracked(?Closure $callback = null): void
187 |     {
188 |         PHPUnit::assertCount(
189 |             0,
190 |             $this->events($callback),
191 |             'The unexpected event was called.'
192 |         );
193 |     }
194 | 
195 |     public function assertEventNotTracked(
196 |         string $event,
197 |         Closure|int|null $callback = null
198 |     ): void {
199 |         PHPUnit::assertCount(
200 |             0,
201 |             $this->events($callback, $event),
202 |             'The expected events were not called.'
203 |         );
204 |     }
205 | 
206 |     public function assertNothingTracked(): void
207 |     {
208 |         $events = collect($this->events);
209 | 
210 |         PHPUnit::assertEmpty(
211 |             $events->all(),
212 |             $events->count().' events were found unexpectedly.'
213 |         );
214 |     }
215 | 
216 |     /**
217 |      * @return array<string, mixed>|null
218 |      */
219 |     public function getContext(): ?array
220 |     {
221 |         return $this->context;
222 |     }
223 | 
224 |     /**
225 |      * @return Collection<int, SimpleSegmentIdentify>
226 |      */
227 |     private function identities(?Closure $callback = null): Collection
228 |     {
229 |         $identities = collect($this->identities);
230 | 
231 |         if ($identities->isEmpty()) {
232 |             return collect();
233 |         }
234 | 
235 |         $callback = $callback ?: fn () => true;
236 | 
237 |         return $identities->filter(
238 |             fn (SimpleSegmentIdentify $identity) => $callback($identity)
239 |         );
240 |     }
241 | 
242 |     /**
243 |      * @return Collection<int, SimpleSegmentEvent>
244 |      */
245 |     private function events(
246 |         ?Closure $callback = null,
247 |         ?string $event = null
248 |     ): Collection {
249 |         $events = collect($this->events);
250 | 
251 |         if ($events->isEmpty()) {
252 |             return collect();
253 |         }
254 | 
255 |         $callback = $callback ?: fn () => true;
256 | 
257 |         return $events
258 |             ->when($event, function (Collection $collection) use ($event) {
259 |                 return $collection->filter(function (
260 |                     SimpleSegmentEvent $segmentEvent
261 |                 ) use ($event) {
262 |                     return $segmentEvent->toSegment()->event === $event;
263 |                 });
264 |             })
265 |             ->filter(fn (SimpleSegmentEvent $event) => $callback($event));
266 |     }
267 | }
268 | 


--------------------------------------------------------------------------------
/src/Facades/Segment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Facades;
 4 | 
 5 | use Closure;
 6 | use Illuminate\Support\Facades\Facade;
 7 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 8 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
 9 | use SlashEquip\LaravelSegment\Contracts\SegmentServiceContract;
10 | use SlashEquip\LaravelSegment\Facades\Fakes\SegmentFake;
11 | use SlashEquip\LaravelSegment\PendingUserSegment;
12 | 
13 | /**
14 |  * @method static void setGlobalUser(CanBeIdentifiedForSegment $globalUser)
15 |  * @method static void setGlobalContext(?array<string, mixed> $globalContext)
16 |  * @method static void track(string $event, ?array<string, mixed> $eventData = null)
17 |  * @method static void trackNow(string $event, ?array<string, mixed> $eventData = null)
18 |  * @method static void identify(?array<string, mixed> $identifyData = null)
19 |  * @method static void identifyNow(?array<string, mixed> $identifyData = null)
20 |  * @method static PendingUserSegment forUser(CanBeIdentifiedForSegment $user)
21 |  * @method static void push(CanBeSentToSegment $segment)
22 |  * @method static void terminate()
23 |  * @method static void assertIdentified(Closure|int|null $callback = null)
24 |  * @method static void assertIdentifiedTimes(int $times)
25 |  * @method static void assertNotIdentified(Closure $callback = null)
26 |  * @method static void assertNothingIdentified()
27 |  * @method static void assertTracked(Closure|int|null $callback = null)
28 |  * @method static void assertTrackedTimes(int $times)
29 |  * @method static void assertEventTracked(string $event,Closure|int|null $callback = null)
30 |  * @method static void assertNotTracked(Closure $callback = null)
31 |  * @method static void assertNothingTracked()
32 |  *
33 |  * @see \SlashEquip\LaravelSegment\SegmentService
34 |  * @see SegmentFake
35 |  */
36 | class Segment extends Facade
37 | {
38 |     protected static function getFacadeAccessor(): string
39 |     {
40 |         return SegmentServiceContract::class;
41 |     }
42 | 
43 |     public static function fake(): SegmentFake
44 |     {
45 |         return tap(new SegmentFake, function (SegmentFake $fake) {
46 |             static::swap($fake);
47 |         });
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/LaravelSegmentServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use Illuminate\Support\Facades\Queue;
 6 | use Illuminate\Support\ServiceProvider;
 7 | use SlashEquip\LaravelSegment\Contracts\SegmentServiceContract;
 8 | use SlashEquip\LaravelSegment\Facades\Segment;
 9 | 
10 | class LaravelSegmentServiceProvider extends ServiceProvider
11 | {
12 |     public function boot(): void
13 |     {
14 |         // Setup config publishing
15 |         $this->publishes([
16 |             __DIR__.'/../config/segment.php' => config_path('segment.php'),
17 |         ]);
18 | 
19 |         /**
20 |          * Send deferred tracking events to Segment after the response has been sent.
21 |          *
22 |          * @psalm-suppress UndefinedInterfaceMethod
23 |          */
24 |         $this->app->terminating(function () {
25 |             Segment::terminate();
26 |         });
27 | 
28 |         // Send deferred tracking events to Segment after a job has been processed.
29 |         Queue::after(function () {
30 |             Segment::terminate();
31 |         });
32 |     }
33 | 
34 |     public function register(): void
35 |     {
36 |         // Register config.
37 |         $this->mergeConfigFrom(
38 |             __DIR__.'/../config/segment.php',
39 |             'segment'
40 |         );
41 | 
42 |         // Register the Segment service.
43 |         $this->app->singleton(SegmentServiceContract::class, function ($app) {
44 |             return new SegmentService($app->make('config')['segment']);
45 |         });
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Middleware/ApplySegmentGlobals.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Middleware;
 4 | 
 5 | use Closure;
 6 | use Illuminate\Http\Request;
 7 | use Illuminate\Support\Facades\Auth;
 8 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 9 | use SlashEquip\LaravelSegment\Facades\Segment;
10 | 
11 | class ApplySegmentGlobals
12 | {
13 |     public function handle(Request $request, Closure $next, mixed $guard = null): mixed
14 |     {
15 |         /**
16 |          * Set the current logged in User as global.
17 |          */
18 |         if ($user = Auth::guard($guard)->user()) {
19 |             /** @var CanBeIdentifiedForSegment $user */
20 |             Segment::setGlobalUser($user);
21 |         }
22 | 
23 |         /**
24 |          * Build some nice default context based on the current request.
25 |          */
26 |         Segment::setGlobalContext($this->getContext($request));
27 | 
28 |         return $next($request);
29 |     }
30 | 
31 |     /**
32 |      * @return array<string, mixed>
33 |      */
34 |     private function getContext(Request $request): array
35 |     {
36 |         return collect([
37 |             'ip' => $request->ip(),
38 |             'locale' => $request->getPreferredLanguage(),
39 |             'userAgent' => $request->userAgent(),
40 | 
41 |             /**
42 |              * This is a solid default, generally backend calls
43 |              * to Segment are not responsible to determining
44 |              * whether or a not a user is active or not.
45 |              */
46 |             'active' => false,
47 |         ])
48 |             ->filter(function ($context) {
49 |                 // Top level null values in the context
50 |                 // are meaningless at this point.
51 |                 return ! is_null($context);
52 |             })
53 |             ->all();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Notifications/SegmentChannel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Notifications;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 6 | use SlashEquip\LaravelSegment\Contracts\CanNotifyViaSegment;
 7 | use SlashEquip\LaravelSegment\Exceptions\NotifiableCannotBeIdentifiedForSegmentException;
 8 | use SlashEquip\LaravelSegment\Facades\Segment;
 9 | 
10 | class SegmentChannel
11 | {
12 |     public function send(object $notifiable, CanNotifyViaSegment $notification): void
13 |     {
14 |         if (! $notifiable instanceof CanBeIdentifiedForSegment) {
15 |             throw new NotifiableCannotBeIdentifiedForSegmentException;
16 |         }
17 | 
18 |         Segment::push($notification->toSegment($notifiable));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/PendingUserSegment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 6 | use SlashEquip\LaravelSegment\Contracts\SegmentServiceContract;
 7 | 
 8 | class PendingUserSegment
 9 | {
10 |     public function __construct(
11 |         private SegmentServiceContract $service,
12 |         private CanBeIdentifiedForSegment $user
13 |     ) {}
14 | 
15 |     /**
16 |      * @param  array<string, mixed>|null  $eventData
17 |      */
18 |     public function track(string $event, ?array $eventData = null): void
19 |     {
20 |         $this->service->push(
21 |             new SimpleSegmentEvent($this->user, $event, $eventData)
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @param  array<string, mixed>|null  $eventData
27 |      */
28 |     public function trackNow(string $event, ?array $eventData = null): void
29 |     {
30 |         $this->service->push(
31 |             new SimpleSegmentEvent($this->user, $event, $eventData)
32 |         );
33 | 
34 |         $this->service->terminate();
35 |     }
36 | 
37 |     /**
38 |      * @param  array<string, mixed>|null  $identifyData
39 |      */
40 |     public function identify(?array $identifyData = null): void
41 |     {
42 |         $this->service->push(
43 |             new SimpleSegmentIdentify($this->user, $identifyData)
44 |         );
45 |     }
46 | 
47 |     /**
48 |      * @param  array<string, mixed>|null  $identifyData
49 |      */
50 |     public function identifyNow(?array $identifyData = null): void
51 |     {
52 |         $this->service->push(
53 |             new SimpleSegmentIdentify($this->user, $identifyData)
54 |         );
55 | 
56 |         $this->service->terminate();
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/SegmentService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SlashEquip\LaravelSegment;
  4 | 
  5 | use Illuminate\Http\Client\Response;
  6 | use Illuminate\Support\Facades\Http;
  7 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
  8 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
  9 | use SlashEquip\LaravelSegment\Contracts\SegmentServiceContract;
 10 | use SlashEquip\LaravelSegment\Contracts\ShouldBeAnonymouslyIdentified;
 11 | use SlashEquip\LaravelSegment\Enums\SegmentPayloadType;
 12 | use SlashEquip\LaravelSegment\ValueObjects\SegmentPayload;
 13 | use Throwable;
 14 | 
 15 | class SegmentService implements SegmentServiceContract
 16 | {
 17 |     const BATCH_URL = 'https://api.segment.io/v1/batch';
 18 | 
 19 |     private CanBeIdentifiedForSegment $globalUser;
 20 | 
 21 |     /** @var array<string, mixed> */
 22 |     private array $globalContext = [];
 23 | 
 24 |     /** @var array<int, mixed> */
 25 |     private array $payloads = [];
 26 | 
 27 |     /**
 28 |      * @param  array<string, mixed>  $config
 29 |      */
 30 |     public function __construct(
 31 |         private readonly array $config
 32 |     ) {}
 33 | 
 34 |     public function setGlobalUser(CanBeIdentifiedForSegment $globalUser): void
 35 |     {
 36 |         $this->globalUser = $globalUser;
 37 |     }
 38 | 
 39 |     /**
 40 |      * @param  array<string, mixed>  $globalContext
 41 |      */
 42 |     public function setGlobalContext(array $globalContext): void
 43 |     {
 44 |         $this->globalContext = $globalContext;
 45 |     }
 46 | 
 47 |     /**
 48 |      * @param  array<string, mixed>  $eventData
 49 |      */
 50 |     public function track(string $event, ?array $eventData = null): void
 51 |     {
 52 |         $this->push(
 53 |             new SimpleSegmentEvent($this->globalUser, $event, $eventData)
 54 |         );
 55 |     }
 56 | 
 57 |     /**
 58 |      * @param  array<string, mixed>  $eventData
 59 |      */
 60 |     public function trackNow(string $event, ?array $eventData = null): void
 61 |     {
 62 |         $this->push(
 63 |             new SimpleSegmentEvent($this->globalUser, $event, $eventData)
 64 |         );
 65 | 
 66 |         $this->terminate();
 67 |     }
 68 | 
 69 |     /**
 70 |      * @param  array<string, mixed>  $identifyData
 71 |      */
 72 |     public function identify(?array $identifyData = null): void
 73 |     {
 74 |         $this->push(
 75 |             new SimpleSegmentIdentify($this->globalUser, $identifyData)
 76 |         );
 77 |     }
 78 | 
 79 |     /**
 80 |      * @param  array<string, mixed>  $identifyData
 81 |      */
 82 |     public function identifyNow(?array $identifyData = null): void
 83 |     {
 84 |         $this->push(
 85 |             new SimpleSegmentIdentify($this->globalUser, $identifyData)
 86 |         );
 87 | 
 88 |         $this->terminate();
 89 |     }
 90 | 
 91 |     public function forUser(CanBeIdentifiedForSegment $user): PendingUserSegment
 92 |     {
 93 |         return new PendingUserSegment($this, $user);
 94 |     }
 95 | 
 96 |     public function push(CanBeSentToSegment $segment): void
 97 |     {
 98 |         $this->payloads[] = $segment->toSegment();
 99 | 
100 |         // We are not deferring so we send now!
101 |         if (! $this->shouldDefer()) {
102 |             $this->terminate();
103 |         }
104 |     }
105 | 
106 |     public function terminate(): void
107 |     {
108 |         if (empty($this->payloads)) {
109 |             return;
110 |         }
111 | 
112 |         if (! $this->isEnabled()) {
113 |             $this->clean();
114 | 
115 |             return;
116 |         }
117 | 
118 |         // Send the batch request.
119 |         $response = Http::asJson()
120 |             ->withToken(base64_encode($this->getWriteKey()))
121 |             ->post(self::BATCH_URL, [
122 |                 'batch' => $this->getBatchData(),
123 |                 'context' => $this->globalContext,
124 |             ]);
125 | 
126 |         // Do error handling.
127 |         $this->handleResponseErrors($response);
128 | 
129 |         // Clean up.
130 |         $this->clean();
131 |     }
132 | 
133 |     /**
134 |      * @return array<int, mixed>
135 |      */
136 |     protected function getBatchData(): array
137 |     {
138 |         return collect($this->payloads)
139 |             ->map(fn (SegmentPayload $payload) => $this->getDataFromPayload($payload))
140 |             ->all();
141 |     }
142 | 
143 |     /**
144 |      * @return array<string, mixed>
145 |      */
146 |     protected function getDataFromPayload(SegmentPayload $payload): array
147 |     {
148 |         $key = $payload->user instanceof ShouldBeAnonymouslyIdentified ? 'anonymousId' : 'userId';
149 | 
150 |         // Initial data.
151 |         $data = [
152 |             'type' => $payload->type->value,
153 |             $key => $payload->user->getSegmentIdentifier(),
154 |             'timestamp' => $payload->timestamp->format('Y-m-d\TH:i:s\Z'),
155 |         ];
156 | 
157 |         // This is important, Segment will not handle empty
158 |         // data arrays as expected and will drop the event.
159 |         if (! empty($payload->data)) {
160 |             $data[$payload->getDataKey()] = $payload->data;
161 |         }
162 | 
163 |         // If it's a tracking call we need an event name!
164 |         if ($payload->type === SegmentPayloadType::Track) {
165 |             $data['event'] = $payload->event;
166 |         }
167 | 
168 |         return $data;
169 |     }
170 | 
171 |     protected function handleResponseErrors(Response $response): void
172 |     {
173 |         \rescue(
174 |             callback: function () use ($response) {
175 |                 // If there was an error then it can be
176 |                 // thrown here and we can process.
177 |                 $response->throw();
178 |             },
179 |             rescue: function (Throwable $e) {
180 |                 // Cleanup and re-throw, we stop here.
181 |                 if (! $this->inSafeMode()) {
182 |                     $this->clean();
183 | 
184 |                     throw $e;
185 |                 }
186 | 
187 |                 // We report manually to prevent duplicate exceptions reports
188 |                 report($e);
189 |             },
190 |             report: false
191 |         );
192 |     }
193 | 
194 |     protected function clean(): void
195 |     {
196 |         $this->payloads = [];
197 |     }
198 | 
199 |     protected function isEnabled(): bool
200 |     {
201 |         return filter_var($this->config['enabled'] ?? true, FILTER_VALIDATE_BOOL);
202 |     }
203 | 
204 |     protected function getWriteKey(): string
205 |     {
206 |         return sprintf('%s:', $this->config['write_key'] ?? '');
207 |     }
208 | 
209 |     protected function shouldDefer(): bool
210 |     {
211 |         return filter_var($this->config['defer'] ?? false, FILTER_VALIDATE_BOOL);
212 |     }
213 | 
214 |     protected function inSafeMode(): bool
215 |     {
216 |         return filter_var($this->config['safe_mode'] ?? true, FILTER_VALIDATE_BOOL);
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/src/SimpleSegmentAnonymousUser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\ShouldBeAnonymouslyIdentified;
 6 | 
 7 | class SimpleSegmentAnonymousUser extends SimpleSegmentUser implements ShouldBeAnonymouslyIdentified
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/src/SimpleSegmentEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 6 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
 7 | use SlashEquip\LaravelSegment\Enums\SegmentPayloadType;
 8 | use SlashEquip\LaravelSegment\ValueObjects\SegmentPayload;
 9 | 
10 | class SimpleSegmentEvent implements CanBeSentToSegment
11 | {
12 |     /**
13 |      * @param  array<string, mixed>  $eventData
14 |      */
15 |     public function __construct(
16 |         private readonly CanBeIdentifiedForSegment $user,
17 |         private readonly string $event,
18 |         private readonly ?array $eventData = null,
19 |     ) {}
20 | 
21 |     public function toSegment(): SegmentPayload
22 |     {
23 |         return new SegmentPayload(
24 |             user: $this->user,
25 |             type: SegmentPayloadType::Track,
26 |             event: $this->event,
27 |             data: $this->eventData ?? [],
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/SimpleSegmentIdentify.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 6 | use SlashEquip\LaravelSegment\Contracts\CanBeSentToSegment;
 7 | use SlashEquip\LaravelSegment\Enums\SegmentPayloadType;
 8 | use SlashEquip\LaravelSegment\ValueObjects\SegmentPayload;
 9 | 
10 | class SimpleSegmentIdentify implements CanBeSentToSegment
11 | {
12 |     /**
13 |      * @param  array<string, mixed>  $identifyData
14 |      */
15 |     public function __construct(
16 |         private CanBeIdentifiedForSegment $user,
17 |         private ?array $identifyData = null
18 |     ) {}
19 | 
20 |     public function toSegment(): SegmentPayload
21 |     {
22 |         return new SegmentPayload(
23 |             user: $this->user,
24 |             type: SegmentPayloadType::Identify,
25 |             data: $this->identifyData ?? [],
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/SimpleSegmentUser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment;
 4 | 
 5 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 6 | 
 7 | class SimpleSegmentUser implements CanBeIdentifiedForSegment
 8 | {
 9 |     public function __construct(
10 |         private string $id
11 |     ) {}
12 | 
13 |     public function getSegmentIdentifier(): string
14 |     {
15 |         return $this->id;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Traits/HasSegmentIdentityByKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\Traits;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | /**
 8 |  * @mixin Model
 9 |  *
10 |  * @phpstan-ignore trait.unused
11 |  */
12 | trait HasSegmentIdentityByKey
13 | {
14 |     public function getSegmentIdentifier(): string
15 |     {
16 |         return (string) $this->getKey();
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/ValueObjects/SegmentPayload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SlashEquip\LaravelSegment\ValueObjects;
 4 | 
 5 | use DateTime;
 6 | use DateTimeZone;
 7 | use SlashEquip\LaravelSegment\Contracts\CanBeIdentifiedForSegment;
 8 | use SlashEquip\LaravelSegment\Enums\SegmentPayloadType;
 9 | 
10 | class SegmentPayload
11 | {
12 |     public readonly DateTime $timestamp;
13 | 
14 |     /**
15 |      * @param  array<string, mixed>  $data
16 |      */
17 |     public function __construct(
18 |         public readonly CanBeIdentifiedForSegment $user,
19 |         public readonly SegmentPayloadType $type,
20 |         public readonly ?string $event = null,
21 |         public readonly array $data = [],
22 |         ?DateTime $timestamp = null
23 |     ) {
24 |         $this->timestamp = $timestamp ?: new DateTime;
25 |         $this->timestamp->setTimezone(new DateTimeZone('UTC'));
26 |     }
27 | 
28 |     public function getDataKey(): string
29 |     {
30 |         return match ($this->type) {
31 |             SegmentPayloadType::Track => 'properties',
32 |             SegmentPayloadType::Identify => 'traits',
33 |         };
34 |     }
35 | }
36 | 


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