Nodarx/mail_manager
1
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Projects Releases Activity

refactor: use resource identifiers #20

Merged
Sebastian merged 1 commits from refactor/use-resource-identifiers into main 2026-05-15 02:34:52 +00:00
Conversation 0 Commits 1 Files Changed 13 +425 -621
13 changed files with 425 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
lib/Controllers/DefaultController.php
View File

@@ -21,7 +21,10 @@ use KTXF\Resource\Identifier\CollectionIdentifier;
use KTXF\Resource\Identifier\EntityIdentifier;
use KTXF\Resource\Identifier\ResourceIdentifier;
use KTXF\Resource\Identifier\ResourceIdentifiers;
use KTXF\Resource\Identifier\ServiceIdentifier;
use KTXF\Resource\Provider\ResourceServiceLocationInterface;
use KTXF\Resource\Selector\CollectionSelector;
use KTXF\Resource\Selector\ServiceSelector;
use KTXF\Resource\Selector\SourceSelector;
use KTXF\Routing\Attributes\AuthenticatedRoute;
use KTXM\MailManager\Manager;
@@ -41,6 +44,7 @@ class DefaultController extends ControllerAbstract {
private const ERR_MISSING_SERVICE = 'Missing parameter: service';
private const ERR_MISSING_COLLECTION = 'Missing parameter: collection';
private const ERR_MISSING_DATA = 'Missing parameter: data';
private const ERR_MISSING_SOURCE = 'Missing parameter: source';
private const ERR_MISSING_SOURCES = 'Missing parameter: sources';
private const ERR_MISSING_TARGET = 'Missing parameter: target';
private const ERR_MISSING_TARGETS = 'Missing parameter: targets';
@@ -51,6 +55,7 @@ class DefaultController extends ControllerAbstract {
private const ERR_INVALID_IDENTIFIER = 'Invalid parameter: identifier must be a string';
private const ERR_INVALID_COLLECTION = 'Invalid parameter: collection must be a string or integer';
private const ERR_INVALID_SOURCES = 'Invalid parameter: sources must be an array';
private const ERR_INVALID_SOURCE = 'Invalid parameter: source must be a string';
private const ERR_INVALID_TARGET = 'Invalid parameter: target must be an array';
private const ERR_INVALID_TARGETS = 'Invalid parameter: targets must be an array';
private const ERR_INVALID_IDENTIFIERS = 'Invalid parameter: identifiers must be an array';
@@ -410,8 +415,14 @@ class DefaultController extends ControllerAbstract {
private function collectionList(string $tenantId, string $userId, array $data): mixed {
$sources = null;
if (isset($data['sources']) && is_array($data['sources'])) {
$sources = new SourceSelector();
$sources->jsonDeserialize($data['sources']);
// TODO: Refactor to use identifiers directly
$sources = ResourceIdentifiers::fromArray($data['sources']);
foreach ($sources as $source) {
if (!$source instanceof CollectionIdentifier && !$source instanceof ServiceIdentifier) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service, provider:service:collection, or provider:service:collection:entity identifiers');
}
}
$sources = $this->createSourceSelectorFromIdentifiers($sources);
}
$filter = $data['filter'] ?? null;
@@ -421,44 +432,50 @@ class DefaultController extends ControllerAbstract {
}
private function collectionFetch(string $tenantId, string $userId, array $data): mixed {
if (!isset($data['provider'])) {
throw new InvalidArgumentException(self::ERR_MISSING_PROVIDER);
if (!isset($data['targets'])) {
throw new InvalidArgumentException(self::ERR_MISSING_TARGETS);
}
if (!is_string($data['provider'])) {
throw new InvalidArgumentException(self::ERR_INVALID_PROVIDER);
}
if (!isset($data['service'])) {
throw new InvalidArgumentException(self::ERR_MISSING_SERVICE);
}
if (!is_string($data['service'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SERVICE);
}
if (!isset($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_MISSING_IDENTIFIER);
}
if (!is_string($data['identifier']) && !is_int($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_INVALID_COLLECTION);
if (!is_array($data['targets'])) {
throw new InvalidArgumentException(self::ERR_INVALID_TARGETS);
}
return $this->mailManager->collectionFetch(
// TODO: Refactor to use identifiers directly
$targetIdentifiers = ResourceIdentifiers::fromArray($data['targets']);
foreach ($targetIdentifiers as $targetIdentifier) {
if (!$targetIdentifier instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: target must be provider:service:collection');
}
}
$list = [];
foreach ($targetIdentifiers as $targetIdentifier) {
$list[(string)$targetIdentifier] = $this->mailManager->collectionFetch(
$tenantId,
$userId,
$data['provider'],
$data['service'],
$data['identifier']
$targetIdentifier->provider(),
$targetIdentifier->service(),
$targetIdentifier->collection()
);
}
return $list;
}
private function collectionExtant(string $tenantId, string $userId, array $data): mixed {
if (!isset($data['sources'])) {
throw new InvalidArgumentException(self::ERR_MISSING_SOURCES);
if (!isset($data['targets'])) {
throw new InvalidArgumentException(self::ERR_MISSING_TARGETS);
}
if (!is_array($data['sources'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SOURCES);
if (!is_array($data['targets'])) {
throw new InvalidArgumentException(self::ERR_INVALID_TARGETS);
}
$sources = new SourceSelector();
$sources->jsonDeserialize($data['sources']);
// TODO: Refactor to use identifiers directly
$sources = ResourceIdentifiers::fromArray($data['targets']);
foreach ($sources as $source) {
if (!$source instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: targets must contain provider:service, provider:service:collection, or provider:service:collection:entity identifiers');
}
}
$sources = $this->createSourceSelectorFromIdentifiers($sources);
return $this->mailManager->collectionExtant($tenantId, $userId, $sources);
}
@@ -476,8 +493,8 @@ class DefaultController extends ControllerAbstract {
if (!is_string($data['service'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SERVICE);
}
if (isset($data['collection']) && !is_string($data['collection']) && !is_int($data['collection'])) {
throw new InvalidArgumentException(self::ERR_INVALID_COLLECTION);
if (isset($data['target']) && !is_string($data['target']) && !is_int($data['target'])) {
throw new InvalidArgumentException(self::ERR_INVALID_TARGET);
}
if (!isset($data['properties'])) {
throw new InvalidArgumentException(self::ERR_MISSING_DATA);
@@ -486,34 +503,29 @@ class DefaultController extends ControllerAbstract {
throw new InvalidArgumentException(self::ERR_INVALID_DATA);
}
if (isset($data['target'])) {
$targetIdentifier = ResourceIdentifier::fromString($data['target']);
if (!$targetIdentifier instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: target must be provider:service:collection');
}
}
return $this->mailManager->collectionCreate(
$tenantId,
$userId,
$data['provider'],
$data['service'],
$data['collection'] ?? null,
$targetIdentifier->collection() ?? null,
$data['properties']
);
}
private function collectionUpdate(string $tenantId, string $userId, array $data): mixed {
if (!isset($data['provider'])) {
throw new InvalidArgumentException(self::ERR_MISSING_PROVIDER);
if (!isset($data['target'])) {
throw new InvalidArgumentException(self::ERR_MISSING_TARGET);
}
if (!is_string($data['provider'])) {
throw new InvalidArgumentException(self::ERR_INVALID_PROVIDER);
}
if (!isset($data['service'])) {
throw new InvalidArgumentException(self::ERR_MISSING_SERVICE);
}
if (!is_string($data['service'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SERVICE);
}
if (!isset($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_MISSING_IDENTIFIER);
}
if (!is_string($data['identifier']) && !is_int($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_INVALID_COLLECTION);
if (!is_string($data['target'])) {
throw new InvalidArgumentException(self::ERR_INVALID_TARGET);
}
if (!isset($data['properties'])) {
throw new InvalidArgumentException(self::ERR_MISSING_DATA);
@@ -522,44 +534,33 @@ class DefaultController extends ControllerAbstract {
throw new InvalidArgumentException(self::ERR_INVALID_DATA);
}
$targetIdentifier = ResourceIdentifier::fromString($data['target']);
if (!$targetIdentifier instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: target must be provider:service:collection');
}
return $this->mailManager->collectionUpdate(
$tenantId,
$userId,
$data['provider'],
$data['service'],
$data['identifier'],
$targetIdentifier,
$data['properties']
);
}
private function collectionDelete(string $tenantId, string $userId, array $data): mixed {
if (!isset($data['provider'])) {
throw new InvalidArgumentException(self::ERR_MISSING_PROVIDER);
if (!isset($data['target'])) {
throw new InvalidArgumentException(self::ERR_MISSING_TARGET);
}
if (!is_string($data['provider'])) {
throw new InvalidArgumentException(self::ERR_INVALID_PROVIDER);
}
if (!isset($data['service'])) {
throw new InvalidArgumentException(self::ERR_MISSING_SERVICE);
}
if (!is_string($data['service'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SERVICE);
}
if (!isset($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_MISSING_IDENTIFIER);
}
if (!is_string($data['identifier']) && !is_int($data['identifier'])) {
throw new InvalidArgumentException(self::ERR_INVALID_IDENTIFIER);
if (!is_string($data['target'])) {
throw new InvalidArgumentException(self::ERR_INVALID_TARGET);
}
$result = $this->mailManager->collectionDelete(
$tenantId,
$userId,
$data['provider'],
$data['service'],
$data['identifier'],
$data['options'] ?? []
);
$targetIdentifier = ResourceIdentifier::fromString($data['target']);
if (!$targetIdentifier instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: target must be provider:service:collection');
}
$result = $this->mailManager->collectionDelete($tenantId, $userId, $targetIdentifier, $data['options'] ?? [] );
if (is_bool($result)) {
return [
@@ -585,10 +586,10 @@ class DefaultController extends ControllerAbstract {
throw new InvalidArgumentException(self::ERR_INVALID_TARGET);
}
if (!isset($data['source'])) {
throw new InvalidArgumentException(self::ERR_MISSING_SOURCE);
throw new InvalidArgumentException(self::ERR_MISSING_SOURCES);
}
if (!is_string($data['source'])) {
throw new InvalidArgumentException(self::ERR_INVALID_SOURCE);
throw new InvalidArgumentException(self::ERR_INVALID_SOURCES);
}
$target = ResourceIdentifier::fromString($data['target']);
@@ -615,8 +616,14 @@ class DefaultController extends ControllerAbstract {
throw new InvalidArgumentException(self::ERR_INVALID_SOURCES);
}
$sources = new SourceSelector();
$sources->jsonDeserialize($data['sources']);
$sources = ResourceIdentifiers::fromArray($data['sources']);
foreach ($sources as $source) {
if (!$source instanceof EntityIdentifier) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service:collection:entity identifiers');
}
}
$sources = $this->createSourceSelectorFromIdentifiers($sources);
$filter = $data['filter'] ?? null;
$sort = $data['sort'] ?? null;
@@ -634,8 +641,14 @@ class DefaultController extends ControllerAbstract {
throw new InvalidArgumentException(self::ERR_INVALID_SOURCES);
}
$sources = new SourceSelector();
$sources->jsonDeserialize($data['sources']);
$sources = ResourceIdentifiers::fromArray($data['sources']);
foreach ($sources as $source) {
if (!$source instanceof ServiceIdentifier && !$source instanceof CollectionIdentifier) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service or provider:service:collection identifiers');
}
}
$sources = $this->createSourceSelectorFromIdentifiers($sources);
$filter = $data['filter'] ?? null;
$sort = $data['sort'] ?? null;
@@ -671,6 +684,50 @@ class DefaultController extends ControllerAbstract {
return new StreamedNdJsonResponse($responseGenerator, 1, 200, ['Content-Type' => 'application/json']);
}
private function createSourceSelectorFromIdentifiers(ResourceIdentifiers $identifiers): SourceSelector {
$sources = new SourceSelector();
foreach ($identifiers as $identifier) {
if (!$identifier instanceof ServiceIdentifier) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service, provider:service:collection, or provider:service:collection:entity identifiers');
}
$provider = $identifier->provider();
$service = $identifier->service();
if (!isset($sources[$provider])) {
$sources[$provider] = new ServiceSelector();
}
$serviceSelector = $sources[$provider];
if (!$serviceSelector instanceof ServiceSelector) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service:collection selectors');
}
if ($identifier instanceof ServiceIdentifier && !$identifier instanceof CollectionIdentifier) {
$serviceSelector[$service] = true;
continue;
}
if (isset($serviceSelector[$service]) && $serviceSelector[$service] === true) {
continue;
}
if (!isset($serviceSelector[$service])) {
$serviceSelector[$service] = new CollectionSelector();
}
$collectionSelector = $serviceSelector[$service];
if (!$collectionSelector instanceof CollectionSelector) {
throw new InvalidArgumentException('Invalid parameter: sources must contain provider:service:collection selectors');
}
$collectionSelector[$identifier->collection()] = true;
}
return $sources;
}
private function entityFetch(string $tenantId, string $userId, array $data): mixed {
if (!isset($data['provider'])) {
throw new InvalidArgumentException(self::ERR_MISSING_PROVIDER);

191
lib/Manager.php
View File

@@ -8,6 +8,7 @@ use InvalidArgumentException;
use KTXC\Resource\ProviderManager;
use KTXF\Mail\Collection\CollectionBaseInterface;
use KTXF\Mail\Collection\CollectionMutableInterface;
use KTXF\Mail\Collection\CollectionPropertiesMutableInterface;
use KTXF\Mail\Collection\ICollectionBase;
use KTXF\Mail\Entity\Address;
use KTXF\Mail\Entity\IMessageBase;
@@ -21,7 +22,9 @@ use KTXF\Mail\Queue\SendOptions;
use KTXF\Mail\Service\IServiceSend;
use KTXF\Mail\Service\ServiceBaseInterface;
use KTXF\Mail\Service\ServiceCollectionMutableInterface;
use KTXF\Mail\Service\ServiceConfigurableInterface;
use KTXF\Mail\Service\ServiceEntityMutableInterface;
use KTXF\Mail\Service\ServiceMutableInterface;
use KTXF\Resource\Filter\IFilter;
use KTXF\Resource\Identifier\CollectionIdentifier;
use KTXF\Resource\Identifier\EntityIdentifier;
@@ -266,6 +269,9 @@ class Manager {
if ($service === null) {
throw new InvalidArgumentException("Service '$serviceId' not found");
}
if ($service instanceof ServiceMutableInterface === false) {
throw new InvalidArgumentException("Service '$serviceId' is not mutable and cannot be updated");
}
// Update with new data
$service->jsonDeserialize($data, $delta);
@@ -416,7 +422,7 @@ class Manager {
throw new InvalidArgumentException('Service identity not valid');
}
/** @var ServiceMutableInterface $service */
/** @var ServiceConfigurableInterface|ServiceMutableInterface $service */
$service = $provider->serviceFresh();
if ($location instanceof ResourceServiceLocationInterface === false) {
$location = $service->freshLocation($location['type'], (array)$location);
@@ -572,18 +578,16 @@ class Manager {
*
* @param string $tenantId tenant identifier
* @param string $userId user identifier
* @param string $providerId provider identifier
* @param string|int $serviceId service identifier
* @param string|int|null $collectionId collection identifier (parent collection)
* @param CollectionMutableInterface|array $object collection to create
* @param CollectionIdentifier $target target parent collection identifier
* @param CollectionPropertiesMutableInterface|array $properties properties for the new collection
* @param array $options additional options for creation
*
* @return CollectionBaseInterface
* @throws InvalidArgumentException
*/
public function collectionCreate(string $tenantId, string $userId, string $providerId, string|int $serviceId, string|int|null $collectionId, CollectionMutableInterface|array $object, array $options = []): CollectionBaseInterface {
public function collectionCreate(string $tenantId, string $userId, string $provider, string|int $service, CollectionIdentifier|null $target, CollectionPropertiesMutableInterface|array $properties, array $options = []): CollectionBaseInterface {
// retrieve service
$service = $this->serviceFetch($tenantId, $userId, $providerId, $serviceId);
$service = $this->serviceFetch($tenantId, $userId, $provider, $service);
// Check if service supports collection creation
if (!($service instanceof ServiceCollectionMutableInterface)) {
@@ -593,15 +597,14 @@ class Manager {
throw new InvalidArgumentException("Service is not capable of creating collections");
}
if (is_array($object)) {
$collection = $service->collectionFresh();
$collection->getProperties()->jsonDeserialize($object);
if (is_array($properties)) {
$collection = $service->collectionFresh()->getProperties()->jsonDeserialize($properties);
} else {
$collection = $object;
$collection = $properties;
}
// Create collection
return $service->collectionCreate($collectionId, $collection, $options);
return $service->collectionCreate($target, $collection, $options);
}
/**
@@ -609,17 +612,15 @@ class Manager {
*
* @param string $tenantId tenant identifier
* @param string $userId user identifier
* @param string $providerId provider identifier
* @param string|int $serviceId service identifier
* @param string|int $collectionId collection identifier
* @param CollectionMutableInterface|array $object collection to modify
* @param CollectionIdentifier $target target collection identifier
* @param CollectionPropertiesMutableInterface|array $properties properties to modify
*
* @return CollectionBaseInterface
* @throws InvalidArgumentException
*/
public function collectionUpdate(string $tenantId, string $userId, string $providerId, string|int $serviceId, string|int $collectionId, CollectionMutableInterface|array $object): CollectionBaseInterface {
public function collectionUpdate(string $tenantId, string $userId, CollectionIdentifier $target, CollectionPropertiesMutableInterface|array $properties): CollectionBaseInterface {
// retrieve service
$service = $this->serviceFetch($tenantId, $userId, $providerId, $serviceId);
$service = $this->serviceFetch($tenantId, $userId, $target->provider(), $target->service());
// Check if service supports collection creation
if (!($service instanceof ServiceCollectionMutableInterface)) {
@@ -629,15 +630,14 @@ class Manager {
throw new InvalidArgumentException("Service is not capable of updating collections");
}
if (is_array($object)) {
$collection = $service->collectionFresh();
$collection->getProperties()->jsonDeserialize($object);
if (is_array($properties)) {
$mutation = $service->collectionFresh()->getProperties()->jsonDeserialize($properties);
} else {
$collection = $object;
$mutation = $properties;
}
// Update collection
return $service->collectionUpdate($collectionId, $collection);
return $service->collectionUpdate($target, $mutation);
}
/**
@@ -647,15 +647,14 @@ class Manager {
*
* @param string $tenantId Tenant identifier
* @param string|null $userId User identifier for context
* @param string $providerId Provider identifier
* @param string|int $serviceId Service identifier
* @param string|int $collectionId Collection identifier
* @param CollectionIdentifier $target Target collection identifier
* @param array $options Additional options for deletion (e.g., 'force' => true to force delete even if not empty)
*
* @return CollectionBaseInterface|null
*/
public function collectionDelete(string $tenantId, ?string $userId, string $providerId, string|int $serviceId, string|int $collectionId, array $options = []): CollectionBaseInterface | bool {
public function collectionDelete(string $tenantId, ?string $userId, CollectionIdentifier $target, array $options = []): CollectionBaseInterface | bool {
// retrieve service
$service = $this->serviceFetch($tenantId, $userId, $providerId, $serviceId);
$service = $this->serviceFetch($tenantId, $userId, $target->provider(), $target->service());
// Check if service supports collection deletion
if (!($service instanceof ServiceCollectionMutableInterface)) {
@@ -668,7 +667,7 @@ class Manager {
$force = $options['force'] ?? false;
// delete collection
return $service->collectionDelete($collectionId, $force);
return $service->collectionDelete($target, $force);
}
/**
@@ -704,7 +703,7 @@ class Manager {
}
// move collection
return $service->collectionMove($source->collection(), $target->collection());
return $service->collectionMove($target, $source);
}
// ==================== Message Operations ====================
@@ -1052,7 +1051,6 @@ class Manager {
}
// Temporarily disabled check until all methods are properly implemented from ServiceEntityMutableInterface
/*
if (!($service instanceof ServiceEntityMutableInterface)) {
foreach ($serviceSources as $identifier) {
$operationOutcome[(string)$identifier] = [
@@ -1072,7 +1070,6 @@ class Manager {
}
continue;
}
*/
return $service->entityDelete(...$serviceSources->all());
}
@@ -1170,12 +1167,12 @@ class Manager {
$targetService = $this->serviceFetch($tenantId, $userId, $target->provider(), $target->service());
// Check if service supports entity move
// Temporarily disabled check until all methods are properly implemented from ServiceEntityMutableInterface
/*
if ($targetService instanceof ServiceEntityMutableInterface === false) {
return [];
}
*/
if (!$targetService->capable(ServiceEntityMutableInterface::CAPABILITY_ENTITY_MOVE)) {
return [];
}
$operationOutcome = [];
@@ -1190,128 +1187,4 @@ class Manager {
return $operationOutcome;
}
/**
* Send a mail message
*
* Routes the message to the appropriate service based on the `from` address.
* By default, messages are queued; use SendOptions::immediate() for urgent messages.
*
* @since 2025.05.01
*
* @param string $tenantId Tenant identifier
* @param string|null $userId User identifier for context
* @param IMessageMutable $message Message to send
* @param SendOptions|null $options Delivery options (defaults to queued)
*
* @return string Job ID for queued messages, or Message ID for immediate sends
*
* @throws SendException On immediate send failure
* @throws InvalidArgumentException If no suitable service found
*/
public function entityTransmit(string $tenantId, ?string $userId, string $providerId, string|int $serviceId, array $data): string {
$options = $options ?? new SendOptions();
// Find the appropriate service
$from = $message->getFrom();
if ($from !== null) {
$service = $this->serviceFindByAddress($tenantId, $userId, $from->getAddress());
}
if ($service === null) {
throw new InvalidArgumentException('No mail service found for the message sender address');
}
// Verify service can send
if (!($service instanceof IServiceSend) || !$service->capable(IServiceSend::CAPABILITY_SEND)) {
throw new InvalidArgumentException('Selected mail service does not support sending');
}
// replace internal address for external 'from'
$message->setFrom((new Address())->setAddress('system@ktrix.local'));
// Immediate send bypasses queue
if ($options->immediate) {
$this->logger->debug('Sending mail immediately', [
'tenant' => $tenantId,
'provider' => $service->in(),
'service' => $service->id(),
'to' => array_map(fn($a) => $a->getAddress(), $message->getTo()),
]);
return $service->messageSend($message);
}
// Queue the message
$jobId = $this->queue->enqueue(
$tenantId,
$service->in(),
$service->id(),
$message,
$options
);
$this->logger->debug('Mail queued for delivery', [
'tenant' => $tenantId,
'jobId' => $jobId,
'provider' => $service->in(),
'service' => $service->id(),
'priority' => $options->priority,
]);
return $jobId;
}
/**
* Process queued mail for a tenant
*
* Called by the mail daemon to process pending messages.
*
* @since 2025.05.01
*
* @param string $tenantId Tenant identifier
* @param int $batchSize Maximum messages to process
*
* @return array{processed: int, failed: int}
*/
public function queueProcess(string $tenantId, int $batchSize = 50): array {
$processed = 0;
$failed = 0;
$jobs = $this->queue->dequeue($tenantId, $batchSize);
foreach ($jobs as $job) {
try {
$service = $this->serviceFetch($tenantId, null, $job->providerId, $job->serviceId);
if ($service === null || !($service instanceof IServiceSend)) {
throw new SendException("Service not found or cannot send: {$job->providerId}/{$job->serviceId}");
}
$messageId = $service->messageSend($job->message);
$this->queue->acknowledge($job->id, $messageId);
$processed++;
$this->logger->debug('Mail sent from queue', [
'tenant' => $tenantId,
'jobId' => $job->id,
'messageId' => $messageId,
]);
} catch (\Throwable $e) {
$isPermanent = $e instanceof SendException && $e->permanent;
$this->queue->reject($job->id, $e->getMessage(), !$isPermanent);
$failed++;
$this->logger->warning('Mail send failed', [
'tenant' => $tenantId,
'jobId' => $job->id,
'error' => $e->getMessage(),
'permanent' => $isPermanent,
]);
}
}
return ['processed' => $processed, 'failed' => $failed];
}
}

13
src/models/collection.ts
View File

@@ -4,6 +4,7 @@
import type { CollectionInterface, CollectionModelInterface, CollectionPropertiesInterface, CollectionPropertiesModelInterface } from "@/types/collection";
import { clonePlain } from './clone-plain';
import type { CollectionIdentifier, ServiceIdentifier } from "@/services";
export class CollectionObject implements CollectionModelInterface {
@@ -49,16 +50,16 @@ export class CollectionObject implements CollectionModelInterface {
return this._data.provider;
}
get service(): string | number {
return this._data.service;
get service(): ServiceIdentifier {
return this._data.service as ServiceIdentifier;
}
get collection(): string | number | null {
return this._data.collection;
get collection(): CollectionIdentifier | null {
return this._data.collection as CollectionIdentifier | null;
}
get identifier(): string | number {
return this._data.identifier;
get identifier(): CollectionIdentifier {
return this._data.identifier as CollectionIdentifier;
}
get signature(): string | null | undefined {

17
src/models/entity.ts
View File

@@ -6,6 +6,7 @@ import type { EntityInterface, EntityModelInterface } from "@/types/entity";
import type { MessageInterface } from "@/types/message";
import { MessageObject } from "./message";
import { clonePlain } from './clone-plain';
import type { CollectionIdentifier, EntityIdentifier, ServiceIdentifier } from "@/services";
export class EntityObject implements EntityModelInterface {
@@ -18,8 +19,8 @@ export class EntityObject implements EntityModelInterface {
version: 1,
provider: '',
service: '',
collection: '',
identifier: '',
collection: null,
identifier: null,
signature: null,
created: null,
modified: null,
@@ -54,16 +55,16 @@ export class EntityObject implements EntityModelInterface {
return this._data.provider;
}
get service(): string {
return this._data.service;
get service(): ServiceIdentifier {
return this._data.service as ServiceIdentifier;
}
get collection(): string|number {
return this._data.collection;
get collection(): CollectionIdentifier {
return this._data.collection as CollectionIdentifier;
}
get identifier(): string|number {
return this._data.identifier;
get identifier(): EntityIdentifier {
return this._data.identifier as EntityIdentifier;
}
get signature(): string | null {

48
src/models/message.ts
View File

@@ -48,38 +48,46 @@ export class MessageObject implements MessageModelInterface {
/** Properties */
get urid(): string | null{
return this._data.urid ?? null;
}
get size(): number {
return this._data.size ?? 0;
}
get receivedDate(): string | null {
return this._data.receivedDate ?? null;
get headers(): Record<string, string> {
return clonePlain(this._data.headers ?? {});
}
get sentDate(): string | null {
return this._data.sentDate ?? null;
get urid(): string | null{
return this._data.urid ?? null;
}
get date(): string | null {
return this._data.date ?? null;
get inReplyTo(): string | null {
return this._data.inReplyTo ?? null;
}
get subject(): string | null {
return this._data.subject ?? null;
get references(): string | null {
return this._data.references ?? null;
}
get snippet(): string | null {
return this._data.snippet ?? null;
get received(): string | null {
return this._data.received ?? null;
}
get sent(): string | null {
return this._data.sent ?? null;
}
get sender(): MessageAddressObject | null {
return this._data.sender ? new MessageAddressObject(this._data.sender) : null;
}
get from(): MessageAddressObject | null {
return this._data.from ? new MessageAddressObject(this._data.from) : null;
}
get replyTo(): Array<MessageAddressObject> | null {
return this._data.replyTo ? this._data.replyTo.map(addr => new MessageAddressObject(addr)) : null;
}
get to(): Array<MessageAddressObject> | null {
return this._data.to ? this._data.to.map(addr => new MessageAddressObject(addr)) : null;
}
@@ -92,12 +100,8 @@ export class MessageObject implements MessageModelInterface {
return this._data.bcc ? this._data.bcc.map(addr => new MessageAddressObject(addr)) : null;
}
get replyTo(): Array<MessageAddressObject> | null {
return this._data.replyTo ? this._data.replyTo.map(addr => new MessageAddressObject(addr)) : null;
}
get flags(): { read?: boolean; flagged?: boolean; answered?: boolean; draft?: boolean } | {} {
return clonePlain(this._data.flags ?? {});
get subject(): string | null {
return this._data.subject ?? null;
}
get body(): MessagePartObject | null {
@@ -115,6 +119,10 @@ export class MessageObject implements MessageModelInterface {
return this._data.attachments ? this._data.attachments.map(att => new MessagePartObject(att)) : [];
}
get flags(): { read?: boolean; flagged?: boolean; answered?: boolean; draft?: boolean } | {} {
return clonePlain(this._data.flags ?? {});
}
/** Helper methods */
get isRead(): boolean {

15
src/services/collectionService.ts
View File

@@ -72,9 +72,16 @@ export const collectionService = {
*
* @returns Promise with collection object
*/
async fetch(request: CollectionFetchRequest): Promise<CollectionObject> {
async fetch(request: CollectionFetchRequest): Promise<Record<string, CollectionObject>> {
const response = await transceivePost<CollectionFetchRequest, CollectionFetchResponse>('collection.fetch', request);
return createCollectionObject(response);
// Convert response to CollectionObject instances
const list: Record<string, CollectionObject> = {};
Object.entries(response).forEach(([identifier, entity]) => {
list[entity.identifier] = createCollectionObject(entity);
});
return list;
},
/**
@@ -128,8 +135,8 @@ export const collectionService = {
async delete(request: CollectionDeleteRequest): Promise<boolean | CollectionObject> {
const response = await transceivePost<CollectionDeleteRequest, CollectionDeleteResponse>('collection.delete', request);
if (response.outcome === 'moved' && response.data) {
return createCollectionObject(response.data);
if (response.disposition === 'moved' && response.mutation) {
return createCollectionObject(response.mutation);
}
return true;

9
src/services/entityService.ts
View File

@@ -87,8 +87,8 @@ export const entityService = {
// Convert response to EntityObject instances
const list: Record<string, EntityObject> = {};
Object.entries(response).forEach(([identifier, entityData]) => {
list[identifier] = createEntityObject(entityData);
Object.entries(response).forEach(([identifier, entity]) => {
list[entity.identifier] = createEntityObject(entity);
});
return list;
@@ -184,10 +184,7 @@ export const entityService = {
*
* @returns Promise resolving to { total } when the stream completes
*/
async stream(
request: EntityStreamRequest,
onEntity: (entity: EntityObject) => void
): Promise<{ total: number }> {
async stream(request: EntityStreamRequest, onEntity: (entity: EntityObject) => void): Promise<{ total: number }> {
return await transceiveStream<EntityStreamRequest, EntityStreamResponse>(
'entity.stream',
request,

212
src/stores/collectionsStore.ts
View File

@@ -4,13 +4,16 @@
import { ref, computed, readonly } from 'vue'
import { defineStore } from 'pinia'
import { collectionService, entityService } from '../services'
import {
type ServiceIdentifier,
type CollectionIdentifier,
type ListFilter,
type ListSort,
collectionService,
} from '../services'
import { CollectionObject, CollectionPropertiesObject } from '../models/collection'
import type { SourceSelector, ListFilter, ListSort, CollectionIdentifier, CollectionMoveResponse } from '../types'
export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
const ROOT_IDENTIFIER = '__root__'
const SERVICE_INDEX_IDENTIFIER = '__service__'
// State
const _collections = ref<Record<string, CollectionObject>>({})
@@ -67,14 +70,13 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Collection object or null
*/
function collection(provider: string, service: string | number, identifier: string | number, retrieve: boolean = false): CollectionObject | null {
const key = identifierKey(provider, service, identifier)
if (retrieve === true && !_collections.value[key]) {
console.debug(`[Mail Manager][Store] - Force fetching collection "${key}"`)
fetch(provider, service, identifier)
function collection(target: CollectionIdentifier, retrieve: boolean = false): CollectionObject | null {
if (retrieve === true && !_collections.value[target]) {
console.debug(`[Mail Manager][Store] - Force fetching collection "${target}"`)
fetch([target])
}
return _collections.value[key] || null
return _collections.value[target] || null
}
/**
@@ -87,18 +89,14 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
* @returns Array of collection objects
*/
function collectionsForService(provider: string, service: string | number, retrieve: boolean = false): CollectionObject[] {
const serviceIdentifier = `${provider}:${service}` as ServiceIdentifier
const serviceCollections = collectionObjectsForKeys(
_collectionsByServiceIndex.value[identifierKey(provider, service, SERVICE_INDEX_IDENTIFIER)] ?? [],
_collectionsByServiceIndex.value[serviceIdentifier] ?? [],
)
if (retrieve === true && serviceCollections.length === 0) {
console.debug(`[Mail Manager][Store] - Force fetching collections for service "${provider}:${service}"`)
const sources: SourceSelector = {
[provider]: {
[String(service)]: true
}
}
list(sources)
console.debug(`[Mail Manager][Store] - Force fetching collections for service "${serviceIdentifier}"`)
list([serviceIdentifier])
}
return serviceCollections
@@ -114,33 +112,23 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Array of direct child collection objects
*/
function collectionsInCollection(provider: string, service: string | number, collectionId: string | number | null, retrieve: boolean = false): CollectionObject[] {
function collectionsInCollection(provider: string, service: string | number, collection?: CollectionIdentifier | null, retrieve: boolean = false): CollectionObject[] {
const collectionIdentifier = collection ?? `${provider}:${service}` as CollectionIdentifier
const nestedCollections = collectionObjectsForKeys(
_collectionsByParentIndex.value[identifierKey(provider, service, collectionId)] ?? [],
_collectionsByParentIndex.value[collectionIdentifier] ?? [],
)
if (retrieve === true && nestedCollections.length === 0) {
console.debug(`[Mail Manager][Store] - Force fetching collections in collection "${provider}:${service}:${collectionId}"`)
const sources: SourceSelector = {
[provider]: {
[String(service)]: true
}
}
list(sources)
console.debug(`[Mail Manager][Store] - Force fetching collections in collection "${collectionIdentifier}"`)
list([collectionIdentifier])
}
return nestedCollections
}
function hasChildrenInCollection(provider: string, service: string | number, collectionId: string | number | null): boolean {
return (_collectionsByParentIndex.value[identifierKey(provider, service, collectionId)]?.length ?? 0) > 0
}
/**
* Create unique key for a collection
*/
function identifierKey(provider: string, service: string | number | null, identifier: string | number | null): string {
return `${provider}:${String(service ?? ROOT_IDENTIFIER)}:${String(identifier ?? ROOT_IDENTIFIER)}`
function hasChildrenInCollection(provider: string, service: string | number, collection: CollectionIdentifier | null): boolean {
const collectionIdentifier = collection ?? `${provider}:${service}` as CollectionIdentifier
return (_collectionsByParentIndex.value[collectionIdentifier]?.length ?? 0) > 0
}
function collectionObjectsForKeys(collectionKeys: string[]): CollectionObject[] {
@@ -149,6 +137,16 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
.filter((collection): collection is CollectionObject => collection !== undefined)
}
function indexCollection(collection: CollectionObject) {
addIndexEntry(_collectionsByServiceIndex.value, String(collection.service), String(collection.identifier))
addIndexEntry(_collectionsByParentIndex.value, String(collection.collection ?? collection.service), String(collection.identifier))
}
function deindexCollection(collection: CollectionObject) {
removeIndexEntry(_collectionsByServiceIndex.value, String(collection.service), String(collection.identifier))
removeIndexEntry(_collectionsByParentIndex.value, String(collection.collection ?? collection.service), String(collection.identifier))
}
function addIndexEntry(index: Record<string, string[]>, indexKey: string, collectionKey: string) {
const existing = index[indexKey] ?? []
@@ -176,24 +174,6 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
index[indexKey] = filtered
}
function indexCollection(collection: CollectionObject) {
const collectionKey = identifierKey(collection.provider, collection.service, collection.identifier)
const serviceIndexKey = identifierKey(collection.provider, collection.service, SERVICE_INDEX_IDENTIFIER)
const parentIndexKey = identifierKey(collection.provider, collection.service, collection.collection)
addIndexEntry(_collectionsByServiceIndex.value, serviceIndexKey, collectionKey)
addIndexEntry(_collectionsByParentIndex.value, parentIndexKey, collectionKey)
}
function deindexCollection(collection: CollectionObject) {
const collectionKey = identifierKey(collection.provider, collection.service, collection.identifier)
const serviceIndexKey = identifierKey(collection.provider, collection.service, SERVICE_INDEX_IDENTIFIER)
const parentIndexKey = identifierKey(collection.provider, collection.service, collection.collection)
removeIndexEntry(_collectionsByServiceIndex.value, serviceIndexKey, collectionKey)
removeIndexEntry(_collectionsByParentIndex.value, parentIndexKey, collectionKey)
}
// Actions
/**
@@ -205,7 +185,7 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Promise with collection object list keyed by provider, service, and collection identifier
*/
async function list(sources?: SourceSelector, filter?: ListFilter, sort?: ListSort): Promise<Record<string, CollectionObject>> {
async function list(sources?: ServiceIdentifier[] | CollectionIdentifier[], filter?: ListFilter, sort?: ListSort): Promise<Record<string, CollectionObject>> {
transceiving.value = true
try {
const response = await collectionService.list({ sources, filter, sort })
@@ -215,14 +195,11 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
Object.entries(response).forEach(([_providerId, providerServices]) => {
Object.entries(providerServices).forEach(([_serviceId, serviceCollections]) => {
Object.entries(serviceCollections).forEach(([_collectionId, collectionObj]) => {
const key = identifierKey(collectionObj.provider, collectionObj.service, collectionObj.identifier)
const previousCollection = _collections.value[key]
if (previousCollection) {
deindexCollection(previousCollection)
if (_collections.value[collectionObj.identifier]) {
deindexCollection(_collections.value[collectionObj.identifier])
}
collections[key] = collectionObj
collections[collectionObj.identifier] = collectionObj
})
})
})
@@ -252,26 +229,25 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Promise with collection object
*/
async function fetch(provider: string, service: string | number, identifier: string | number): Promise<CollectionObject> {
async function fetch(targets: CollectionIdentifier[]): Promise<Record<string, CollectionObject>> {
transceiving.value = true
try {
const response = await collectionService.fetch({ provider, service, collection: identifier })
const response = await collectionService.fetch({ targets })
// Merge fetched collection into state
const key = identifierKey(response.provider, response.service, response.identifier)
const previousCollection = _collections.value[key]
if (previousCollection) {
deindexCollection(previousCollection)
Object.values(response).forEach(collectionObj => {
if (_collections.value[collectionObj.identifier]) {
deindexCollection(_collections.value[collectionObj.identifier])
}
_collections.value[key] = response
indexCollection(response)
_collections.value[collectionObj.identifier] = collectionObj
indexCollection(collectionObj)
})
console.debug('[Mail Manager][Store] - Successfully fetched collection:', key)
console.debug('[Mail Manager][Store] - Successfully fetched collections:', Object.keys(response).join(', '))
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to fetch collection:', error)
console.error('[Mail Manager][Store] - Failed to fetch collections:', error)
throw error
} finally {
transceiving.value = false
@@ -285,12 +261,12 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Promise with collection availability status
*/
async function extant(sources: SourceSelector) {
async function extant(targets: CollectionIdentifier[]): Promise<Record<string, Record<string, Record<string, boolean>>>> {
transceiving.value = true
try {
const response = await collectionService.extant({ sources })
const response = await collectionService.extant({ targets })
console.debug('[Mail Manager][Store] - Successfully checked', sources ? Object.keys(sources).length : 0, 'collections')
console.debug('[Mail Manager][Store] - Successfully checked', targets ? targets.length : 0, 'collections')
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to check collections:', error)
@@ -310,22 +286,21 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
*
* @returns Promise with created collection object
*/
async function create(provider: string, service: string | number, collection: string | number | null, data: CollectionPropertiesObject): Promise<CollectionObject> {
async function create(provider: string, service: string | number, properties: CollectionPropertiesObject, target?: CollectionIdentifier): Promise<CollectionObject> {
transceiving.value = true
try {
const response = await collectionService.create({
provider,
service,
collection,
properties: data
target,
properties: properties.toJson()
})
// Merge created collection into state
const key = identifierKey(response.provider, response.service, response.identifier)
_collections.value[key] = response
_collections.value[response.identifier] = response
indexCollection(response)
console.debug('[Mail Manager][Store] - Successfully created collection:', key)
console.debug('[Mail Manager][Store] - Successfully created collection:', response.identifier)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to create collection:', error)
@@ -336,37 +311,29 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
}
/**
* Update an existing collection with given provider, service, identifier, and data
* Update an existing collection with given target and properties
*
* @param provider - provider identifier for the collection to update
* @param service - service identifier for the collection to update
* @param identifier - collection identifier for the collection to update
* @param data - collection properties for update
* @param target - collection identifier for the collection to update
* @param properties - collection properties for update
*
* @returns Promise with updated collection object
*/
async function update(provider: string, service: string | number, identifier: string | number, data: CollectionPropertiesObject): Promise<CollectionObject> {
async function update(target: CollectionIdentifier, properties: CollectionPropertiesObject): Promise<CollectionObject> {
transceiving.value = true
try {
const response = await collectionService.update({
provider,
service,
identifier,
properties: data
target,
properties: properties.toJson()
})
// Merge updated collection into state
const key = identifierKey(response.provider, response.service, response.identifier)
const previousCollection = _collections.value[key]
if (previousCollection) {
deindexCollection(previousCollection)
if (_collections.value[response.identifier]) {
deindexCollection(_collections.value[response.identifier])
}
_collections.value[key] = response
_collections.value[response.identifier] = response
indexCollection(response)
console.debug('[Mail Manager][Store] - Successfully updated collection:', key)
console.debug('[Mail Manager][Store] - Successfully updated collection:', response.identifier)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to update collection:', error)
@@ -377,45 +344,38 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
}
/**
* Delete a collection by provider, service, and identifier
* Delete a collection by identifier, with optional force delete if collection is not empty.
*
* @param provider - provider identifier for the collection to delete
* @param service - service identifier for the collection to delete
* @param identifier - collection identifier for the collection to delete
* @param target - collection identifier for the collection to delete
* @param force - optional flag to force delete if collection is not empty
*
* @returns Promise with deletion result
*/
async function remove(provider: string, service: string | number, identifier: string | number): Promise<CollectionObject | boolean> {
async function remove(target: CollectionIdentifier, force?: boolean): Promise<CollectionObject | boolean> {
transceiving.value = true
try {
const response = await collectionService.delete({ provider, service, identifier })
const response = await collectionService.delete({ target, options: { force } })
if (response !== true && !(response instanceof CollectionObject)) {
console.warn('[Mail Manager][Store] - Delete failed. Received unexpected response from delete operation:', response)
return false
}
const key = identifierKey(provider, service, identifier)
const previousCollection = _collections.value[key]
if (previousCollection) {
deindexCollection(previousCollection)
if (_collections.value[target]) {
deindexCollection(_collections.value[target])
}
delete _collections.value[key]
delete _collections.value[target]
if (response instanceof CollectionObject) {
const movedCollection = response
const movedKey = identifierKey(movedCollection.provider, movedCollection.service, movedCollection.identifier)
_collections.value[response.identifier] = response
indexCollection(response)
_collections.value[movedKey] = movedCollection
indexCollection(movedCollection)
console.debug('[Mail Manager][Store] - Successfully moved collection to trash', key, '->', movedKey)
console.debug('[Mail Manager][Store] - Successfully moved collection to trash', target, '->', response.identifier)
return response
}
console.debug('[Mail Manager][Store] - Successfully deleted collection:', key)
console.debug('[Mail Manager][Store] - Successfully deleted collection:', target)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to delete collection:', error)
@@ -446,21 +406,15 @@ export const useCollectionsStore = defineStore('mailCollectionsStore', () => {
throw new Error('Failed to move collection: unexpected response from move operation')
}
const sourceCollection = _collections.value[source]
if (sourceCollection) {
deindexCollection(sourceCollection)
if (_collections.value[source]) {
deindexCollection(_collections.value[source])
}
delete _collections.value[source]
const movedCollection = response
const movedKey = identifierKey(movedCollection.provider, movedCollection.service, movedCollection.identifier)
_collections.value[response.identifier] = response
indexCollection(response)
_collections.value[movedKey] = movedCollection
indexCollection(movedCollection)
console.debug('[Mail Manager][Store] - Successfully moved collection:', source, ' to ', movedKey)
console.debug('[Mail Manager][Store] - Successfully moved collection:', source, ' to ', response.identifier)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to move collection:', error)

233
src/stores/entitiesStore.ts
View File

@@ -5,10 +5,8 @@
import { ref, computed, readonly } from 'vue'
import { defineStore } from 'pinia'
import { entityService } from '../services'
import { EntityObject } from '../models'
import { EntityObject, MessageObject } from '../models'
import type {
EntityDeleteResponse,
EntityMoveResponse,
EntityStreamRequest,
EntityTransmitRequest,
EntityTransmitResponse,
@@ -19,8 +17,8 @@ import type {
ListFilter,
ListRange,
ListSort,
SourceSelector,
} from '../types/common'
import type { MessageInterface } from '@/types/message'
export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
// State
@@ -53,43 +51,13 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Entity object or null
*/
function entity(provider: string, service: string | number, collection: string | number, identifier: string | number, retrieve: boolean = false): EntityObject | null {
const key = identifierKey(provider, service, collection, identifier)
if (retrieve === true && !_entities.value[key]) {
console.debug(`[Mail Manager][Store] - Force fetching entity "${key}"`)
fetch(provider, service, collection, [identifier])
function entity(target: EntityIdentifier, retrieve: boolean = false): EntityObject | null {
if (retrieve === true && !_entities.value[target]) {
console.debug(`[Mail Manager][Store] - Force fetching entity "${target}"`)
fetch([target])
}
return _entities.value[key] || null
}
/**
* Resolve an entity from cache by full entity identifier.
*/
function entityByIdentifier(identifier: EntityIdentifier, retrieve: boolean = false): EntityObject | null {
if (retrieve === true && !_entities.value[identifier]) {
console.debug(`[Mail Manager][Store] - Force fetching entity "${identifier}"`)
const { provider, service, collection, identifier: id } = parseEntityIdentifier(identifier)
fetch(provider, service, collection, [id])
}
return _entities.value[identifier] || null
}
/**
* Resolve multiple entities from cache by full entity identifiers.
*/
function entitiesByIdentifiers(identifiers: EntityIdentifier[], retrieve: boolean = false): Record<EntityIdentifier, EntityObject> {
const resolved: Record<EntityIdentifier, EntityObject> = {} as Record<EntityIdentifier, EntityObject>
Array.from(new Set(identifiers)).forEach(identifier => {
const entity = entityByIdentifier(identifier, retrieve)
if (entity) {
resolved[identifier] = entity
}
})
return resolved
return _entities.value[target] || null
}
/**
@@ -102,52 +70,19 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Array of entity objects
*/
function entitiesForCollection(provider: string, service: string | number, collection: string | number, retrieve: boolean = false): EntityObject[] {
const collectionKeyPrefix = `${provider}:${service}:${collection}:`
function entitiesForCollection(target: CollectionIdentifier, retrieve: boolean = false): EntityObject[] {
const collectionEntities = Object.entries(_entities.value)
.filter(([key]) => key.startsWith(collectionKeyPrefix))
.filter(([key]) => key.startsWith(target))
.map(([_, entity]) => entity)
if (retrieve === true && collectionEntities.length === 0) {
console.debug(`[Mail Manager][Store] - Force fetching entities for collection "${provider}:${service}:${collection}"`)
const sources: SourceSelector = {
[provider]: {
[String(service)]: {
[String(collection)]: true
}
}
}
list(sources)
console.debug(`[Mail Manager][Store] - Force fetching entities for collection "${target}"`)
list([target])
}
return collectionEntities
}
/**
* Create unique key for an entity
*/
function identifierKey(provider: string, service: string | number, collection: string | number, identifier: string | number): string {
return `${provider}:${service}:${collection}:${identifier}`
}
/**
* Parse a full entity identifier into its components.
*/
function parseEntityIdentifier(identifier: EntityIdentifier): {
provider: string
service: string
collection: string
identifier: string
} {
const [provider, service, collection, entity] = identifier.split(':', 4)
return {
provider,
service,
collection,
identifier: entity,
}
}
// Actions
/**
@@ -160,19 +95,18 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise with entity object list keyed by identifier
*/
async function list(sources?: SourceSelector, filter?: ListFilter, sort?: ListSort, range?: ListRange): Promise<Record<string, EntityObject>> {
async function list(sources: CollectionIdentifier[], filter?: ListFilter, sort?: ListSort, range?: ListRange): Promise<Record<string, EntityObject>> {
transceiving.value = true
try {
const added: Record<string, EntityObject> = {}
const entities: Record<string, EntityObject> = {}
await entityService.stream({ sources, filter, sort, range }, (entity: EntityObject) => {
const key = identifierKey(entity.provider, entity.service, entity.collection, entity.identifier)
_entities.value[key] = entity
added[key] = entity
_entities.value[entity.identifier] = entity
entities[entity.identifier] = entity
})
console.debug('[Mail Manager][Store] - Successfully retrieved', Object.keys(added).length, 'entities')
return added
console.debug('[Mail Manager][Store] - Successfully retrieved', Object.keys(entities).length, 'entities')
return entities
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to retrieve entities:', error)
throw error
@@ -191,17 +125,16 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise with entity objects keyed by identifier
*/
async function fetch(provider: string, service: string | number, collection: string | number, identifiers: (string | number)[]): Promise<Record<string, EntityObject>> {
async function fetch(targets: EntityIdentifier[]): Promise<Record<string, EntityObject>> {
transceiving.value = true
try {
const response = await entityService.fetch({ provider, service, collection, identifiers })
const response = await entityService.fetch({ targets })
// Merge fetched entities into state
const entities: Record<string, EntityObject> = {}
Object.entries(response).forEach(([identifier, entityData]) => {
const key = identifierKey(provider, service, collection, identifier)
entities[key] = entityData
_entities.value[key] = entityData
Object.entries(response).forEach(([identifier, entity]) => {
entities[identifier] = entity
_entities.value[identifier] = entity
})
console.debug('[Mail Manager][Store] - Successfully fetched', Object.keys(entities).length, 'entities')
@@ -215,16 +148,16 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
}
/**
* Retrieve entity availability status for a given source selector
* Retrieve entity availability status for a given set of entity identifiers
*
* @param sources - source selector to check availability for
* @param targets - array of entity identifiers to check availability for
*
* @returns Promise with entity availability status
*/
async function extant(sources: SourceSelector) {
async function extant(targets: EntityIdentifier[]) {
transceiving.value = true
try {
const response = await entityService.extant({ sources })
const response = await entityService.extant({ targets })
console.debug('[Mail Manager][Store] - Successfully checked entity availability')
return response
} catch (error: any) {
@@ -245,7 +178,7 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
* Note: Delta returns only identifiers, not full entities.
* Caller should fetch full entities for additions/modifications separately.
*/
async function delta(sources: SourceSelector) {
async function delta(sources: CollectionIdentifier[]) {
transceiving.value = true
try {
const response = await entityService.delta({ sources })
@@ -266,13 +199,9 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
// Process deletions (remove from store)
if (collectionData.deletions && collectionData.deletions.length > 0) {
collectionData.deletions.forEach((identifier) => {
const key = identifierKey(provider, service, collection, identifier)
delete _entities.value[key]
delete _entities.value[identifier]
})
}
// Note: additions and modifications contain only identifiers
// The caller should fetch full entities using the fetch() method
})
})
})
@@ -288,25 +217,25 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
}
/**
* Create a new entity with given provider, service, collection, and data
* Create a new entity with given collection identifier and properties
*
* @param provider - provider identifier for the new entity
* @param service - service identifier for the new entity
* @param collection - collection identifier for the new entity
* @param data - entity properties for creation
* @param target - collection identifier for the new entity
* @param properties - entity properties for creation
*
* @returns Promise with created entity object
*/
async function create(provider: string, service: string | number, collection: string | number, data: any): Promise<EntityObject> {
async function create(target: CollectionIdentifier, properties: MessageInterface | MessageObject): Promise<EntityObject> {
transceiving.value = true
try {
const response = await entityService.create({ provider, service, collection, properties: data })
if (properties instanceof MessageObject) {
properties = properties.toJson()
}
const response = await entityService.create({ target, properties })
// Add created entity to state
const key = identifierKey(response.provider, response.service, response.collection, response.identifier)
_entities.value[key] = response
_entities.value[response.identifier] = response
console.debug('[Mail Manager][Store] - Successfully created entity:', key)
console.debug('[Mail Manager][Store] - Successfully created entity:', response.identifier)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to create entity:', error)
@@ -327,16 +256,18 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise with updated entity object
*/
async function update(provider: string, service: string | number, collection: string | number, identifier: string | number, data: any): Promise<EntityObject> {
async function update(target: EntityIdentifier, properties: MessageInterface | MessageObject): Promise<EntityObject> {
transceiving.value = true
try {
const response = await entityService.update({ provider, service, collection, identifier, properties: data })
if (properties instanceof MessageObject) {
properties = properties.toJson()
}
const response = await entityService.update({ target, properties })
// Update entity in state
const key = identifierKey(response.provider, response.service, response.collection, response.identifier)
_entities.value[key] = response
_entities.value[response.identifier] = response
console.debug('[Mail Manager][Store] - Successfully updated entity:', key)
console.debug('[Mail Manager][Store] - Successfully updated entity:', response.identifier)
return response
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to update entity:', error)
@@ -355,7 +286,7 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise with deletion results keyed by source identifier
*/
async function remove(sources: EntityIdentifier[]): Promise<EntityDeleteResponse> {
async function remove(sources: EntityIdentifier[]): Promise<{successes: EntityIdentifier[], failures: EntityIdentifier[]}> {
transceiving.value = true
try {
const response = await entityService.delete({ sources })
@@ -363,42 +294,39 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
const failures: EntityIdentifier[] = []
Object.entries(response).forEach(([sourceIdentifier, result]) => {
const originalIdentifier = sourceIdentifier as EntityIdentifier
if (!result.disposition || result.disposition === 'error') {
console.warn(`[Mail Manager][Store] - Entity move on "${sourceIdentifier}" returned an error: ${result.error})`)
failures.push(sourceIdentifier)
console.warn(`[Mail Manager][Store] - Entity move on "${originalIdentifier}" returned an error: ${result.error})`)
failures.push(originalIdentifier)
return
}
if (!result.disposition || (result.disposition !== 'moved' && result.disposition !== 'deleted')) {
console.warn(`[Mail Manager][Store] - Entity move on "${sourceIdentifier}" returned invalid disposition: ${result.disposition})`)
failures.push(sourceIdentifier)
console.warn(`[Mail Manager][Store] - Entity move on "${originalIdentifier}" returned invalid disposition: ${result.disposition})`)
failures.push(originalIdentifier)
return
}
const cachedEntity = _entities.value[sourceIdentifier]
const cachedEntity = _entities.value[originalIdentifier]
if (!cachedEntity) {
return
}
if (result.disposition === 'moved') {
const mutation = parseEntityIdentifier(result.mutation?.identifier || sourceIdentifier)
const movedEntity = cachedEntity.clone().fromJson({
...cachedEntity.toJson(),
provider: mutation.provider,
service: mutation.service,
collection: mutation.collection,
identifier: mutation.identifier,
collection: result.destination,
identifier: result.mutation,
})
const key = identifierKey(mutation.provider, mutation.service, mutation.collection, mutation.identifier)
_entities.value[key] = movedEntity
_entities.value[result.mutation] = movedEntity
}
delete _entities.value[sourceIdentifier]
successes.push(sourceIdentifier)
delete _entities.value[originalIdentifier]
successes.push(originalIdentifier)
})
console.debug('[Mail Manager][Store] - Successfully deleted', Object.keys(response).length, 'entities')
return [successes, failures]
console.debug('[Mail Manager][Store] - Successfully deleted', successes.length, 'entities')
return { successes, failures }
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to delete entities:', error)
throw error
@@ -418,7 +346,7 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise with move results keyed by source identifier
*/
async function move(target: CollectionIdentifier, sources: EntityIdentifier[]): Promise<EntityIdentifier[]> {
async function move(target: CollectionIdentifier, sources: EntityIdentifier[]): Promise<{successes: EntityIdentifier[], failures: EntityIdentifier[]}> {
transceiving.value = true
try {
const response = await entityService.move({ target, sources })
@@ -426,40 +354,37 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
const failures: EntityIdentifier[] = []
Object.entries(response).forEach(([sourceIdentifier, result]) => {
const originalIdentifier = sourceIdentifier as EntityIdentifier
if (!result.disposition || result.disposition === 'error') {
console.warn(`[Mail Manager][Store] - Entity move on "${sourceIdentifier}" returned an error: ${result.error})`)
failures.push(sourceIdentifier)
console.warn(`[Mail Manager][Store] - Entity move on "${originalIdentifier}" returned an error: ${result.error})`)
failures.push(originalIdentifier)
return
}
if (!result.disposition || result.disposition !== 'moved') {
console.warn(`[Mail Manager][Store] - Entity move on "${sourceIdentifier}" returned invalid disposition: ${result.disposition})`)
failures.push(sourceIdentifier)
console.warn(`[Mail Manager][Store] - Entity move on "${originalIdentifier}" returned invalid disposition: ${result.disposition})`)
failures.push(originalIdentifier)
return
}
const cachedEntity = _entities.value[sourceIdentifier]
const cachedEntity = _entities.value[originalIdentifier]
if (!cachedEntity) {
return
}
const mutation = parseEntityIdentifier(result.mutation?.identifier || sourceIdentifier)
const movedEntity = cachedEntity.clone().fromJson({
...cachedEntity.toJson(),
provider: mutation.provider,
service: mutation.service,
collection: mutation.collection,
identifier: mutation.identifier,
collection: result.destination,
identifier: result.mutation,
})
const movedKey = identifierKey(mutation.provider, mutation.service, mutation.collection, mutation.identifier)
_entities.value[movedKey] = movedEntity
_entities.value[result.mutation] = movedEntity
delete _entities.value[sourceIdentifier]
successes.push(sourceIdentifier)
delete _entities.value[originalIdentifier]
successes.push(originalIdentifier)
})
console.debug('[Mail Manager][Store] - Successfully moved', Object.keys(response).length, 'entities')
return [successes, failures]
console.debug('[Mail Manager][Store] - Successfully moved', successes.length, 'entities')
return { successes, failures }
} catch (error: any) {
console.error('[Mail Manager][Store] - Failed to move entities:', error)
throw error
@@ -502,18 +427,12 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
*
* @returns Promise resolving to { total } when the stream completes
*/
async function stream(
sources?: SourceSelector,
filter?: ListFilter,
sort?: ListSort,
range?: ListRange
): Promise<{ total: number }> {
async function stream(sources?: CollectionIdentifier[], filter?: ListFilter, sort?: ListSort, range?: ListRange): Promise<{ total: number }> {
transceiving.value = true
try {
const request: EntityStreamRequest = { sources, filter, sort, range }
const result = await entityService.stream(request, (entity: EntityObject) => {
const key = identifierKey(entity.provider, entity.service, entity.collection, entity.identifier)
_entities.value[key] = entity
_entities.value[entity.identifier] = entity
})
console.debug('[Mail Manager][Store] - Successfully streamed', result.total, 'entities')
return result
@@ -534,9 +453,7 @@ export const useEntitiesStore = defineStore('mailEntitiesStore', () => {
has,
entities,
entitiesForCollection,
entitiesByIdentifiers,
entity,
entityByIdentifier,
list,
fetch,
extant,

32
src/types/collection.ts
View File

@@ -1,7 +1,7 @@
/**
* Collection type definitions
*/
import type { CollectionIdentifier, ListFilter, ListSort, SourceSelector } from './common';
import type { CollectionIdentifier, ListFilter, ListSort, ServiceIdentifier, SourceSelector } from './common';
/**
* Collection information
@@ -11,8 +11,8 @@ export interface CollectionInterface<T = CollectionPropertiesInterface> {
version: number;
provider: string;
service: string | number;
collection: string | number | null;
identifier: string | number;
collection: CollectionIdentifier | null;
identifier: CollectionIdentifier;
signature?: string | null;
created?: string | null;
modified?: string | null;
@@ -47,7 +47,7 @@ export interface CollectionPropertiesModelInterface extends Omit<CollectionPrope
* Collection list
*/
export interface CollectionListRequest {
sources?: SourceSelector;
sources?: ServiceIdentifier[] | CollectionIdentifier[];
filter?: ListFilter;
sort?: ListSort;
}
@@ -64,18 +64,18 @@ export interface CollectionListResponse {
* Collection fetch
*/
export interface CollectionFetchRequest {
provider: string;
service: string | number;
collection: string | number;
targets: CollectionIdentifier[];
}
export interface CollectionFetchResponse extends CollectionInterface {}
export interface CollectionFetchResponse {
[identifier: CollectionIdentifier]: CollectionInterface;
}
/**
* Collection extant
*/
export interface CollectionExtantRequest {
sources: SourceSelector;
targets: CollectionIdentifier[];
}
export interface CollectionExtantResponse {
@@ -92,7 +92,7 @@ export interface CollectionExtantResponse {
export interface CollectionCreateRequest {
provider: string;
service: string | number;
collection?: string | number | null; // Parent Collection Identifier
target?: CollectionIdentifier; // Optional parent target for the new collection
properties: CollectionMutableProperties;
}
@@ -102,9 +102,7 @@ export interface CollectionCreateResponse extends CollectionInterface {}
* Collection modify
*/
export interface CollectionUpdateRequest {
provider: string;
service: string | number;
identifier: string | number;
target: CollectionIdentifier;
properties: CollectionMutableProperties;
}
@@ -114,17 +112,15 @@ export interface CollectionUpdateResponse extends CollectionInterface {}
* Collection delete
*/
export interface CollectionDeleteRequest {
provider: string;
service: string | number;
identifier: string | number;
target: CollectionIdentifier;
options?: {
force?: boolean; // Whether to force delete even if collection is not empty
};
}
export interface CollectionDeleteResponse {
outcome: 'deleted' | 'moved';
data?: CollectionInterface | null; // If moved, the new location of the collection
disposition: 'deleted' | 'moved';
mutation?: CollectionInterface | null; // If moved, the new location of the collection
}
/**

4
src/types/common.ts
View File

@@ -115,8 +115,8 @@ export type EntitySelector = (string | number)[];
export type ProviderIdentifier = `${string}`;
export type ServiceIdentifier = `${string}:${string}`;
export type CollectionIdentifier = `${string}:${string}:${string}`;
export type EntityIdentifier = `${string}:${string}:${string}:${string}`;
export type CollectionIdentifier = `${string}:${string}:${string | number}`;
export type EntityIdentifier = `${string}:${string}:${string}:${string | number}`;
/**
* Filter comparison for list operations

27
src/types/entity.ts
View File

@@ -4,7 +4,6 @@
import type {
CollectionIdentifier,
EntityIdentifier,
SourceSelector,
ListFilter,
ListRange,
ListSort,
@@ -19,8 +18,8 @@ export interface EntityInterface<T = MessageInterface> {
version: number;
provider: string;
service: string;
collection: string | number;
identifier: string | number;
collection: CollectionIdentifier;
identifier: EntityIdentifier;
signature: string | null;
created: string | null;
modified: string | null;
@@ -33,7 +32,7 @@ export interface EntityModelInterface extends Omit<EntityInterface<MessageModelI
* Entity list
*/
export interface EntityListRequest {
sources?: SourceSelector;
sources?: CollectionIdentifier[];
filter?: ListFilter;
sort?: ListSort;
range?: ListRange;
@@ -53,10 +52,7 @@ export interface EntityListResponse {
* Entity fetch
*/
export interface EntityFetchRequest {
provider: string;
service: string | number;
collection: string | number;
identifiers: (string | number)[];
targets: EntityIdentifier[];
}
export interface EntityFetchResponse {
@@ -67,7 +63,7 @@ export interface EntityFetchResponse {
* Entity extant
*/
export interface EntityExtantRequest {
sources: SourceSelector;
targets: EntityIdentifier[];
}
export interface EntityExtantResponse {
@@ -84,7 +80,7 @@ export interface EntityExtantResponse {
* Entity delta
*/
export interface EntityDeltaRequest {
sources: SourceSelector;
sources: CollectionIdentifier[];
}
export interface EntityDeltaResponse {
@@ -104,9 +100,7 @@ export interface EntityDeltaResponse {
* Entity create
*/
export interface EntityCreateRequest<T = MessageInterface> {
provider: string;
service: string | number;
collection: string | number;
target: CollectionIdentifier;
properties: T;
}
@@ -116,10 +110,7 @@ export interface EntityCreateResponse<T = MessageInterface> extends EntityInterf
* Entity update
*/
export interface EntityUpdateRequest<T = MessageInterface> {
provider: string;
service: string | number;
collection: string | number;
identifier: string | number;
target: EntityIdentifier;
properties: T;
}
@@ -193,7 +184,7 @@ export interface EntityTransmitResponse {
* Entity stream
*/
export interface EntityStreamRequest {
sources?: SourceSelector;
sources?: CollectionIdentifier[];
filter?: ListFilter;
sort?: ListSort;
range?: ListRange;

18
src/types/message.ts
View File

@@ -10,21 +10,23 @@ export interface MessageModelInterface extends Omit<{
export interface MessageInterface {
'@type': string;
urid?: string | null;
size?: number | null;
date?: string | null;
receivedDate?: string | null;
sentDate?: string | null;
subject?: string | null;
snippet?: string | null;
headers?: Record<string, string> | null;
urid?: string | null;
inReplyTo?: string | null;
references?: string | null;
received?: string | null;
sent?: string | null;
sender?: MessageAddressInterface | null;
from?: MessageAddressInterface | null;
replyTo?: Array<MessageAddressInterface> | null;
to?: Array<MessageAddressInterface> | null;
cc?: Array<MessageAddressInterface> | null;
bcc?: Array<MessageAddressInterface> | null;
replyTo?: Array<MessageAddressInterface> | null;
flags?: MessageFlagsInterface | null;
subject?: string | null;
body?: MessagePartInterface | null;
attachments?: Array<MessagePartInterface> | [];
flags?: MessageFlagsInterface | null;
}
export interface MessageAddressInterface {