Forem: sebk69

TypeOrm Unit Of Work

sebk69 — Mon, 20 Apr 2026 20:11:36 +0000

Small TypeOrm Persist Thread implement unit of work like a lot of modern ORMs for type-orm.

Benefits :

It optimize the persist flow by grouping orders in single request resulting in less db load and faster response
You can use multi connections persist if your persist is not a transaction
It push you orders in a persist stack that you can flush in one time then even with no transation if your process fail it result as no db actions in result of no db load at all

Use it for your projects with heavy write operations.

git : https://git.small-project.dev/npm-libs/small-typeorm-persist-thread
npm : npm install small-typeorm-persist-thread

Introducing @small-project/collection

sebk69 — Sun, 26 Oct 2025 21:28:45 +0000

Managing arrays and maps in JavaScript can quickly become messy, especially when you want type safety and functional APIs like map, filter, or groupBy.

That’s why I built @small-project/collection, a minimal yet powerful library that brings typed, fluent collections to JavaScript and TypeScript — similar to Laravel Collections, but fully modernized.

Installation

npm install @small-project/collection

Then import what you need:

import { Collection, NumberCollection, StringCollection } from "@small-project/collection";

What is a Collection?

A Collection wraps a native Map but gives you a clean, fluent, and type-safe API to manipulate data.

import { Collection } from "@small-project/collection";

const users = new Collection({
  a: { name: "Alice", age: 25 },
  b: { name: "Bob", age: 30 },
});

console.log(users.keys()); // ['a', 'b']
console.log(users.where({ age: 30 }).values()); // [{ name: 'Bob', age: 30 }]

It supports:

Typed keys and values (Collection<K,V>)
map, filter, reduce, groupBy, sortBy
Conversions to arrays or plain objects
Deep selection via select('users.*.email')

NumberCollection — Math made simple

The NumberCollection extends Collection<number, number> with math utilities:

import { NumberCollection } from "@small-project/collection";

const numbers = new NumberCollection([10, 20, 30, 40]);

console.log(numbers.sum());  // 100
console.log(numbers.mean()); // 25
console.log(numbers.std());  // 11.18
console.log(numbers.normalize().values()); // [0, 0.33, 0.66, 1]

Features:

sum(), mean(), median()
variance(), std()
abs(), multiply(), divide()
greaterThan(), between()
normalize(), uniqueValues(), sortAsc(), sortDesc()

Perfect for datasets, statistics, and numeric analysis in Node or browser.

StringCollection — manipulate text fluently

The StringCollection extends Collection<number, string> and gives you elegant text manipulation.

import { StringCollection } from "@small-project/collection";

const words = new StringCollection(["  hello ", "WORLD ", "déjà vu"]);

console.log(words.trim().capitalize().values());
// ["Hello", "World", "Déjà vu"]

console.log(words.removeAccents().toSlug().values());
// ["hello", "world", "deja-vu"]

Features:

Case handling: toUpper(), toLower(), capitalize()
Trimming & filtering: trim(), nonEmpty(), lengthBetween()
Transformations: replaceAll(), prepend(), append()
Conversion: toSlug(), toPascalCase(), toCamelCase()
Utilities: join(), joinLines(), uniqueIgnoreCase()

Why another collection library?

Because none of the existing ones were:

Fully typed with generics
ES module & CommonJS compatible
Minimal (no dependencies)
Extendable with domain-specific logic (like NumberCollection)

This library is designed for TypeScript-first development and clean, functional codebases.

Documentation

GitHub & npm

git → small-project/collection
npm → @small-project/collection

Small Nest Keycloak

sebk69 — Tue, 21 Oct 2025 05:49:20 +0000

Unusual from me : a typescript package :

Small Nest Keycloak is a minimal, type-safe NestJS integration with Keycloak.
Includes a ready-to-use AuthController, JWT strategy (cookie/header), role decorator and guards.

Quick Start (NestJS)

import { Module } from '@nestjs/common';
import { KeycloakModule } from '@small/nest-keycloak';

@Module({
  imports: [
    KeycloakModule.register({
      baseUrl: process.env.KEYCLOAK_BASE_URL ?? 'http://localhost:8080/auth',
      realm: process.env.KEYCLOAK_REALM ?? 'master',
      clientId: process.env.KEYCLOAK_CLIENT_ID ?? 'nest-app'
    }),
  ],
})
export class AppModule {}

Guards and roles

import { Controller, Get, UseGuards } from '@nestjs/common';
import { JwtAuthGuard, RolesGuard, Roles } from '@small/nest-keycloak';

@Controller('users')
@UseGuards(JwtAuthGuard, RolesGuard)
export class UserController {
  @Get()
  @Roles('admin')
  list() { return ['user1']; }
}

Example `.env`

KEYCLOAK_BASE_URL=http://localhost:8080/auth
KEYCLOAK_REALM=master
KEYCLOAK_CLIENT_ID=nest-app
ACCESS_COOKIE=access_token
REFRESH_COOKIE=refresh_token
PORT=3000

Small Id Generator

sebk69 — Sat, 04 Oct 2025 20:31:35 +0000

I wanted a php library with no composer dependencies to generate unique id, and I finally wrote this : small/id

A tiny PHP library that provides a uniform interface to generate a variety of unique identifiers:
UUID (v1/2/3/4/5/6/7), ULID, KSUID, Snowflake, ObjectId, and NanoID — via a simple IdInterface and a factory.

use Small\Id\IdFactory;
use Small\Id\Enum\IdType;

$factory = new IdFactory();

$uuid7 = $factory->getId(IdType::uuid_v7)->generate();   // e.g. "018fb27a-a2b1-7c3d-8e9f-1a2b3c4d5e6f"
$ulid  = $factory->getId(IdType::ulid)->generate();      // e.g. "01J234ABCD3EFG4567HJKMNPRT"
$ksuid = $factory->getId(IdType::ksuid)->generate();     // base62 string (~27 chars)
$snow  = $factory->getId(IdType::snowflacke)->generate();// decimal string (64‑bit composed)
$oid   = $factory->getId(IdType::objectid)->generate();  // 24‑hex Mongo‑like
$nano  = $factory->getId(IdType::nanoid)->generate();    // 21 chars URL‑safe

Get it

composer require small/id

git : https://git.small-project.dev/lib/small-id
packagist : https://packagist.org/packages/small/id

Small Dependency Injection

sebk69 — Sat, 27 Sep 2025 19:48:39 +0000

Introducing small/dependency-injection

I’ve just released small/dependency-injection — a lightweight, framework-agnostic Dependency Injection container for PHP 8.4.

Quick Start

Install via Composer:

composer require small/dependency-injection

Define your container configuration:

<?php

use Small\DependencyInjection\AbstractContainerConfiguration;
use function Small\DependencyInjection\injectService;
use function Small\DependencyInjection\injectParameter;

class AppConfig extends AbstractContainerConfiguration
{
    public function configure(): self
    {
        $this->parameter('secret', 'top-secret')
             ->service(
                 MyServiceInterface::class,
                 MyService::class,
                 [
                     injectParameter('secret'),
                     injectService(LoggerInterface::class),
                 ]
             )
             ->autowireNamespace('App');

        return $this;
    }
}

Use it:

$config = new AppConfig(__DIR__ . '/composer.json');
$config->loadParameters($container);

$myService = $container->get(MyServiceInterface::class);

Small Swoole Rx Events

sebk69 — Fri, 19 Sep 2025 20:59:56 +0000

Reactive event bus for PHP powered by RxPHP and Swoole.

It lets you publish/subscribe domain and infrastructure events, compose pipelines with Rx operators, and run time-based operators on Swoole’s event loop.

EventBus — simple Rx‐backed bus with on(), onMany(), payloads(), once(), request()
SwooleScheduler — AsyncSchedulerInterface using Swoole\Timer (works with RxPHP time operators)
Event model — BasicEvent (name, payload, meta, rid) and EventInterface (correlation id)

Requirements

PHP 8.3+
ext-swoole 4.8+ / 5.x
reactivex/rxphp (2.x)

Installation

composer require small/swoole-rx-events

Quick start

use Small\SwooleRxEvents\EventBus;
use Small\SwooleRxEvents\SwooleScheduler;
use Small\SwooleRxEvents\Event\BasicEvent;

// Use the Swoole async scheduler
$bus = new EventBus(new SwooleScheduler());

// Subscribe by name
$bus->on('order.created')->subscribe(function ($e) {
    echo "order rid={$e->getRid()} payload=", json_encode($e->getPayload()), PHP_EOL;
});

// Emit an event
$bus->emitName('order.created', ['id' => 123]);

// If you’re in a plain CLI script, keep the loop alive briefly:
\Swoole\Timer::after(20, fn () => \Swoole\Event::exit());
\Swoole\Event::wait();

Concepts

Event

All event must implement EventInterface

namespace Small\SwooleRxEvents\Contract;

interface EventInterface
{

    public function getName(): string;
    public function getRid(): string;
    public function setRid(string $rid): self;

}

BasicEvent carries:

name (string)
payload (array)
meta (array, e.g. tracing, user)
rid (string, auto‐generated correlation id)

Bus

stream() — all events
on($name) / onMany([...]) — filtered streams
payloads($name) — payload‐only stream
once($name, ?map, ?timeoutMs) — resolve first matching event (optionally mapped)
request($requestName, $responseName, $payload = [], $meta = [], ?$timeoutMs) Emits a request with a new rid, waits for the first response with the same rid.

Timeouts require an async scheduler. This library provides SwooleScheduler which implements AsyncSchedulerInterface.

API Examples

1) Listen & emit

$bus->on('user.created')->subscribe(fn($e) => audit($e->getMeta(), $e->getPayload()));
$bus->emitName('user.created', ['id' => 42], ['by' => 'admin']);

2) Request/Response with correlation id

// Responder: copies rid from incoming 'REQ' and emits 'RESP'
$bus->on('REQ')->subscribe(function ($e) use ($bus) {
    $bus->emit(
        (new BasicEvent('RESP', ['ok' => true], $e->getMeta()))
            ->setRid($e->getRid())   // correlate
    );
});

// Caller: request() subscribes FIRST, then emits; no race conditions
$bus->request('REQ', 'RESP', ['foo' => 'bar'], ['trace' => 'abc'], 100)
    ->subscribe(
        fn($resp) => var_dump($resp->getPayload()),          // ['ok' => true]
        fn($err)  => error_log($err->getMessage())
    );

3) `once()` with mapping & timeout

$bus->once('health.ok', fn($e) => $e->getMeta()['node'] ?? 'unknown', 50)
    ->subscribe(
        fn($node) => echo "node=$node\n",
        fn($err)  => echo "timeout\n"
    );
$bus->emitName('health.ok', [], ['node' => 'api-1']);

4) Backpressure / batching (Rx composition)

$bus->on('order.created')
    ->bufferWithTimeOrCount(500, 100, $bus->scheduler()) // every 0.5s or 100 items
    ->filter(fn($batch) => !empty($batch))
    ->subscribe(fn(array $batch) => persist_batch($batch));

Swoole integration tips

HTTP server: in on('request'), emit an event with meta containing a respond callable or the Response object. Downstream subscribers can produce a ResponseEvent.
Coroutines per subscriber: use Swoole coroutines in your subscribers if you do IO; Rx operators will orchestrate sequencing.
Event loop in CLI: outside a Swoole Server, start/stop the reactor with Swoole\Event::wait() / Event::exit() for timers to fire.

Small Resource Server & Symfony Client Bundle

sebk69 — Wed, 03 Sep 2025 19:02:41 +0000

The Small Resource Server is designed to handle resource locking and synchronization efficiently in high-load microservices environments. By centralizing resource access, it prevents race conditions and inconsistent state across distributed services, while remaining lightweight and fast thanks to its Swoole-based concurrency model. This reduces contention, improves throughput, and ensures that critical operations—like payments, reservations, or inventory updates—remain reliable even under heavy parallel traffic.

It also allowing you a good way for long multi processes / muti servers batches synchronization.

Small Resource Server offers a tiny, language‑agnostic HTTP API for just that:

Acquire a named lock with optional TTL & owner token
Sharing associated data

The Symfony Client Bundle gives you ergonomic, resilient access from Symfony with

HttpClientInterface integration
DI configuration (base_uri, API key, timeouts)
Straightforward Resource facade/service APIs

Architecture (high level)

Small Resource Server
- Runtime: PHP + Swoole/OpenSwoole HTTP server
- In‑memory map of resourceName -> lease with optional pluggable storage (Redis/DB) if enabled
- Lease data: owner, token, acquiredAt, ttl, expiresAt
- Background janitor to evict expired leases
- Minimal REST endpoints
Client Bundle (Symfony)
- Registers a named HTTP client preconfigured with base_uri, headers (x-api-key), and default timeouts
- Exposes a ResourceFactory / ResourceClient service to acquire(), renew(), and release()
- Optional retry/backoff on transient errors and clock skew tolerance

HTTP API (server)

Create resource

POST /resource
Headers:
  x-api-key: <WRITE key>

Body (JSON):
{
  "name": "printer",
  "timeout": 300            // optional server-side semantics
}

201 Created
Content-Type: application/json
{ ...resource... }

Get resource data (with optional lock)

GET /resource/{resourceName}/{selector}?lock=1
Headers:
  x-api-key: <READ or READ+LOCK>
  x-ticket: <existing ticket | optional>

Query:
  lock=1  (default)  → attempt to acquire/keep lock
  lock=0             → read without locking

Responses:
- 200 OK + JSON body     → resource data is available
  + Header: x-ticket: <ticket>
- 202 Accepted           → not available yet (locked by someone else),
  body: { "unavailable": true }
  + Header: x-ticket: <ticket> (your ticket to retry with)
- 404 Not Found          → resource/selector unknown
- 401 Unauthorized       → missing/invalid x-api-key / missing LOCK when lock=1

Update resource data

PUT /resource/{resourceName}/{selector}
Headers:
  x-api-key: <WRITE key>
  x-ticket: <ticket from GET>

Body: raw JSON payload to store

204 No Content

Unlock resource

POST /resource/{resourceName}/{selector}/unlock
Headers:
  x-api-key: <READ+LOCK>
  x-ticket: <ticket>

200 OK
{ "unlocked": true }

Security: Accept an x-api-key header; prefer TLS; rate‑limit abusive clients.

📦 Installation

Server (Docker Hub image)

The easiest way to run the server is via Docker:

# Pull the latest image from Docker Hub
docker pull smallphp/small-resource-server:latest

# Run it (adjust API_KEY and port as needed)
docker run -d \
  --name resource-server \
  --volume "./conf/small-swoole-resource-server.conf:/etc/small-swoole-resource-server.conf" \
  -p 8080:9501 \
  smallphp/small-resource-server:latest

You can now access the server on http://localhost:8080.

Docker Compose example:

version: '3.8'
services:
  resource-server:
    image: smallphp/small-resource-server:latest
    restart: unless-stopped
    ports:
      - "8080:9501"
    volumes:
      - ./conf/small-swoole-resource-server.conf:/etc/small-swoole-resource-server.conf
  database:
    container_name: small-swoole-resource-db
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: secret
    command: ["mysqld", "--mysql-native-password=FORCE"]

And config file example:

MYSQL_HOST=database
MYSQL_USER=root
MYSQL_PASSWORD=secret
RESOURCE_READ=d8e8fca2dc0f896fd7cb4cb0031ba249
RESOURCE_READ_LOCK=ed4779d230afc18ca8df5213ba02b11e
RESOURCE_WRITE=eadd7e1bbc06f288417df096bbedfa61

Symfony Client Bundle

Add the bundle to your app:

composer require small/swoole-resource-client-bundle

return [
    Small\SwooleResourceClientBundle\SmallSwooleResourceClientBundle::class => ['all' => true],
];

Configure the client:

# config/packages/small_resource_client.yaml
small_swoole_resource_client:
  base_uri: '%env(RESOURCE_SERVER_BASE_URI)%'
  api_key:  '%env(RESOURCE_SERVER_API_KEY)%'
  timeout: 10

Environment:

###> Small Resource Server ###
RESOURCE_SERVER_BASE_URI=http://localhost:8080
RESOURCE_SERVER_API_KEY=eadd7e1bbc06f288417df096bbedfa61
###< Small Resource Server ###

Quick start from Symfony

$lock = $this->resources->create('shop:42:inventory');
if ($lock->acquire('sync-worker', 30)) {
    $guard = $lock->autoRenew(every: 20, ttl: 30);
    try {
        $this->syncInventory();
    } finally {
        $guard->stop();
        $lock->release();
    }
}

Error handling & edge cases

409 Conflict → someone else holds the lock
403 Forbidden → token mismatch/expired
Timeouts → handle with retry/backoff
Crash safety → expired leases are automatically evicted

Security

All traffic over HTTPS in production
Protect with API keys (env var API_KEY)
Rotate secrets regularly

sources

On github

resource server : https://github.com/sebk69/small-resource-server.git
Symfony client bundle : https://github.com/ebk69/small-swoole-resource-client-bundle.git

On Docker Hub (server)

https://hub.docker.com/repository/docker/smallphp/small-resource-server

On Packagist (Symfony client bundle)

https://packagist.org/packages/small/swoole-resource-client-bundle

Small Forms 1.7.0

sebk69 — Fri, 13 Dec 2024 00:32:37 +0000

New Release of small/forms: 1.7.0

Now supports form creation: the adapter annotation can now process classes with a recursive definition.
New method: fillFromObject
Added the objectToArray method to serialize an object into a PHP array.

class InputBasic
{
    #[StringType]
    private string          $string;
    #[BooleanType]
    private bool            $boolean;
    #[IntType]
    private int             $int;
    #[FloatType]
    private float           $float;
    #[ArrayType(new IntType())]
    private array           $array;
    #[SubFormType(InputBasic::class)]
    private InputBasic|null $subObject = null;
}

$dto = new \Small\Forms\Test\Fixture\InputObject\InputBasic();
$dto->setArray([2, 3]);
$dto->setSubObject(
    (new \Small\Forms\Test\Fixture\InputObject\InputBasic())
    ->setString('string2')
    ->setArray([6, 7])
);

$form = \Small\Forms\Form\FormBuilder::createFromAdapter(
    new \Small\Forms\Adapter\AnnotationAdapter($dto)
);

git repo : https://git.small-project.dev/lib/small-forms
packagist : https://packagist.org/packages/small/forms

Implementing a DDD Use Case in PHP

sebk69 — Sun, 10 Nov 2024 12:53:00 +0000

Implementing a DDD Use Case for in PHP

This article explores a Domain-Driven Design (DDD) Use Case model in PHP, demonstrating how to utilize interfaces and domain-specific classes to manage data persistence. We'll examine the TaxPersistUseCase class, which uses a persistence manager (TaxManagerInterface) to save an entity of type Tax, representing a tax.

This model emphasizes DDD principles : each component is clearly separated into interfaces, concrete implementations, and exceptions, following best practices in dependency injection and error handling.

Structure of the TaxPersistUseCase

The TaxPersistUseCase class handles the business logic associated with persisting a tax. It’s divided into several sections to clarify the logic and structure of this approach.

Dependency Declarations

namespace Domain\Application\UseCase\Order;

use Domain\Application\Entity\Order\Tax;
use Domain\Application\Gateway\Manager\Order\TaxManagerInterface;
use Domain\Application\UseCase\Order\Exception\NotFoundException;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistRequestInterface;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistResponseInterface;
use Domain\Exception\BadRequestException;
use Domain\Exception\FormException;
use Small\CleanApplication\Contract\UseCaseInterface;
use Small\Collection\Collection\StringCollection;
use Small\SwooleEntityManager\EntityManager\Exception\EmptyResultException;

The TaxPersistUseCase class depends on several interfaces and exceptions to handle tax persistence. Here’s a breakdown of their roles:

TaxManagerInterface : Interface for the tax persistence manager.

TaxPersistRequestInterface and TaxPersistResponseInterface : Interfaces for the Use Case’s request and response.
Exceptions: Various exceptions, such as BadRequestException, FormException, and NotFoundException, help manage context-specific errors.

Implementation of the TaxPersistUseCase Class

class TaxPersistUseCase implements UseCaseInterface
{

    public function __construct(
        protected TaxManagerInterface $taxManager,
    ) {}

    public function execute(mixed $request): TaxPersistResponseInterface
    {

        if (!$request instanceof TaxPersistRequestInterface) {
            throw new BadRequestException(
                self::class . ' accepts only request instance of ' . TaxPersistRequestInterface::class
            );
        }

        $tax = $request->getTax();
        $messages = new StringCollection();

        try {
            $this->taxManager->applicationPersist($tax);
        } catch (EmptyResultException $e) {
            throw new NotFoundException($e->getMessage());
        } catch (FormException $e) {
            $messages = $e->getFormMessages();
        }

        return new class($tax, $messages) implements TaxPersistResponseInterface
        {
            public function __construct(
                protected readonly Tax $tax,
                protected readonly StringCollection $messages,
            ) {}

            public function getTax(): Tax
            {
                return $this->tax;
            }

            public function getMessages(): StringCollection
            {
                return $this->messages;
            }
        };

    }

}

Constructor and Dependency Injection : The constructor injects an instance of TaxManagerInterface, delegating the persistence of Tax objects to this instance without coupling TaxPersistUseCase to a specific implementation.
Request Type Checking: The execute method verifies that the $request object implements the TaxPersistRequestInterface. This ensures that the request received conforms to the expected contract, providing interface-level validation.
Persisting the Tax Object : If the request is valid, the Use Case extracts the Tax object from $request via getTax() and calls the applicationPersist method on TaxManagerInterface. This persistence process is encapsulated within a try-catch block to handle potential exceptions
EmptyResultException: If the Tax entity is not found, this exception is caught and a NotFoundException is thrown to signal the error.
FormException: If form validation fails, a FormException is captured, and error messages are stored in a StringCollection.
Dynamic Response via Anonymous Class : An anonymous class implements TaxPersistResponseInterface to return the Use Case’s response. It includes getTax() and getMessages() methods, allowing access to the Tax entity and any error messages, respectively.

Use Case Interfaces

The interfaces define the contracts that each component must adhere to, promoting decoupling and testability.

TaxManagerInterface

This interface specifies the methods for managing taxes, including retrieval and persistence :

interface TaxManagerInterface
{
    public function findById(int $id): Tax;
    public function findByName(string $name): Tax;
    public function applicationPersist(Tax $tax): self;
}

findById() and findByName(): These methods enable retrieving a tax by ID or name.
applicationPersist(): This method ensures the Tax entity’s persistence.

TaxPersistRequestInterface

This interface defines the structure of the request expected by TaxPersistUseCase:

interface TaxPersistRequestInterface extends RequestInterface
{
    public function getTax(): Tax;
}

getTax() : This method returns the Tax entity to be persisted, allowing the Use Case to directly access the relevant domain object. TaxPersistResponseInterface
The response interface ensures that TaxPersistUseCase returns a compliant response:

interface TaxPersistResponseInterface extends ResponseInterface
{
    public function getTax(): ?Tax;
    public function getMessages(): StringCollection;
}

getTax(): Returns the persisted Tax entity or null if an error occurred.
getMessages(): Returns a StringCollection containing error messages, if form errors occurred.

Error and Exception Handling

Exceptions play an important role in DDD by capturing domain-specific errors:

BadRequestException: Thrown if the Use Case receives a request of an incorrect type.
NotFoundException: Thrown when the Tax entity sought is not found.
FormException: Caught to handle validation errors, with error messages returned in a StringCollection.

Small Entity Schema

sebk69 — Tue, 15 Oct 2024 08:22:05 +0000

Small Entity Schema is a class schema designer disguised in library in order to integrate any composer project.

It is specialized on Small Swoole Entity Manager ORM entities generation and update.

Your modifications on PHP classes :

Comments
implements
Attributes
Custom properties
Methods

will be keep during update process.

Screenshots

Install

composer require small/entity-schema

Serve application

composer entity-schema-start

and go to your navigator :

http://localhost:5173

Stop serving

composer entity-schema-stop

Small Swoole Entity Manager Bundle

sebk69 — Fri, 04 Oct 2024 18:59:59 +0000

As promised, here is a Symfony bundle for Small Swoole Entity Manager.

It provides:

A standard Symfony configuration
Service access to the ConnectionFactory
Service access to the EntityManagerFactory
A command to execute the database layers

Links

Documentation : https://swoole-entity-manager.small-project.dev/symfony-bundle/
Git repo : https://git.small-project.dev/lib/small-swoole-entity-manager-bundle
Packagist repo : https://packagist.org/packages/small/swoole-entity-manager-bundle

Small Swoole Entity Manager

sebk69 — Mon, 30 Sep 2024 18:56:26 +0000

I am pleased to present Small Swoole Entity Manager.

It is an ORM architected around Swoole (and OpenSwoole).

It supports asynchronous connections to:

MySQL
Postgres
Small Swoole Db (A relational layer on top of Swoole Tables)

For now, only the core package is available; a Symfony bundle will be released in the coming days.

The Core package can be used for "from scratch" projects.

The documentation is available at https://swoole-entity-manager.small-project.dev

The Git repository: https://git.small-project.dev/lib/small-swoole-entity-manager

The Composer repository: https://packagist.org/packages/small/swoole-entity-manager-core

Forem: sebk69

TypeOrm Unit Of Work

Introducing @small-project/collection

Installation

What is a Collection?

NumberCollection — Math made simple

StringCollection — manipulate text fluently

Why another collection library?

Documentation

GitHub & npm

Small Nest Keycloak

Quick Start (NestJS)

Guards and roles

Example .env

Small Id Generator

Get it

Small Dependency Injection

Introducing small/dependency-injection

Quick Start

Links

Small Swoole Rx Events

Requirements

Installation

Quick start

Concepts

Event

Bus

API Examples

1) Listen & emit

2) Request/Response with correlation id

3) once() with mapping & timeout

4) Backpressure / batching (Rx composition)

Swoole integration tips

Small Resource Server & Symfony Client Bundle

Architecture (high level)

HTTP API (server)

Create resource

Get resource data (with optional lock)

Update resource data

Unlock resource

📦 Installation

Server (Docker Hub image)

Symfony Client Bundle

Quick start from Symfony

Error handling & edge cases

Security

sources

Small Forms 1.7.0

Implementing a DDD Use Case in PHP

Implementing a DDD Use Case for in PHP

Structure of the TaxPersistUseCase

Dependency Declarations

TaxManagerInterface : Interface for the tax persistence manager.

Implementation of the TaxPersistUseCase Class

Use Case Interfaces

TaxManagerInterface

TaxPersistRequestInterface

Error and Exception Handling

Small Entity Schema

Screenshots

Install

Serve application

Stop serving

Small Swoole Entity Manager Bundle

Small Swoole Entity Manager

Example `.env`

3) `once()` with mapping & timeout