Initial commit

src/services/collectionService.ts

@@ -0,0 +1,84 @@
+/**
+ * Collection management service
+ */
+
+import { transceivePost } from './transceive';
+import type {
+  CollectionListRequest,
+  CollectionListResponse,
+  CollectionExtantRequest,
+  CollectionExtantResponse,
+  CollectionFetchRequest,
+  CollectionFetchResponse,
+  CollectionCreateRequest,
+  CollectionCreateResponse,
+  CollectionModifyRequest,
+  CollectionModifyResponse,
+  CollectionDestroyRequest,
+  CollectionDestroyResponse
+} from '../types/collection';
+
+export const collectionService = {
+
+  /**
+   * List all available collections
+   * 
+   * @param request - Collection list request parameters
+   * @returns Promise with collection list grouped by provider and service
+   */
+  async list(request: CollectionListRequest = {}): Promise<CollectionListResponse> {
+    return await transceivePost<CollectionListRequest, CollectionListResponse>('collection.list', request);
+  },
+
+  /**
+   * Check which collections exist/are available
+   * 
+   * @param request - Collection extant request with source selector
+   * @returns Promise with collection availability status
+   */
+  async extant(request: CollectionExtantRequest): Promise<CollectionExtantResponse> {
+    return await transceivePost<CollectionExtantRequest, CollectionExtantResponse>('collection.extant', request);
+  },
+
+  /**
+   * Fetch a specific collection
+   * 
+   * @param request - Collection fetch request
+   * @returns Promise with collection details
+   */
+  async fetch(request: CollectionFetchRequest): Promise<CollectionFetchResponse> {
+    return await transceivePost<CollectionFetchRequest, CollectionFetchResponse>('collection.fetch', request);
+  },
+
+  /**
+   * Create a new collection/folder
+   * 
+   * @param request - Collection creation parameters
+   * @returns Promise with created collection details
+   */
+  async create(request: CollectionCreateRequest): Promise<CollectionCreateResponse> {
+    return await transceivePost<CollectionCreateRequest, CollectionCreateResponse>('collection.create', request);
+  },
+
+  /**
+   * Modify an existing collection/folder
+   * 
+   * @param request - Collection modification parameters
+   * @returns Promise with modified collection details
+   */
+  async modify(request: CollectionModifyRequest): Promise<CollectionModifyResponse> {
+    return await transceivePost<CollectionModifyRequest, CollectionModifyResponse>('collection.modify', request);
+  },
+
+  /**
+   * Destroy/delete a collection/folder
+   * 
+   * @param request - Collection destroy parameters
+   * @returns Promise with destroy operation result
+   */
+  async destroy(request: CollectionDestroyRequest): Promise<CollectionDestroyResponse> {
+    return await transceivePost<CollectionDestroyRequest, CollectionDestroyResponse>('collection.destroy', request);
+  },
+};
+
+export default collectionService;

src/services/entityService.ts

@@ -0,0 +1,120 @@
+/**
+ * Message/Entity management service
+ */
+
+import { transceivePost } from './transceive';
+import type {
+  MessageListRequest,
+  MessageListResponse,
+  MessageDeltaRequest,
+  MessageDeltaResponse,
+  MessageExtantRequest,
+  MessageExtantResponse,
+  MessageFetchRequest,
+  MessageFetchResponse,
+  MessageSearchRequest,
+  MessageSearchResponse,
+  MessageSendRequest,
+  MessageSendResponse,
+  MessageCreateRequest,
+  MessageCreateResponse,
+  MessageUpdateRequest,
+  MessageUpdateResponse,
+  MessageDestroyRequest,
+  MessageDestroyResponse,
+} from '../types/entity';
+
+export const entityService = {
+
+  /**
+   * List all available messages
+   * 
+   * @param request - Message list request parameters
+   * @returns Promise with message list grouped by provider, service, and collection
+   */
+  async list(request: MessageListRequest = {}): Promise<MessageListResponse> {
+    return await transceivePost<MessageListRequest, MessageListResponse>('entity.list', request);
+  },
+
+  /**
+   * Get delta changes for messages
+   * 
+   * @param request - Message delta request with source selector
+   * @returns Promise with delta changes (created, modified, deleted)
+   */
+  async delta(request: MessageDeltaRequest): Promise<MessageDeltaResponse> {
+    return await transceivePost('entity.delta', request);
+  },
+
+  /**
+   * Check which messages exist/are available
+   * 
+   * @param request - Message extant request with source selector
+   * @returns Promise with message availability status
+   */
+  async extant(request: MessageExtantRequest): Promise<MessageExtantResponse> {
+    return await transceivePost('entity.extant', request);
+  },
+
+  /**
+   * Fetch specific messages
+   * 
+   * @param request - Message fetch request
+   * @returns Promise with message details
+   */
+  async fetch(request: MessageFetchRequest): Promise<MessageFetchResponse> {
+    return await transceivePost('entity.fetch', request);
+  },
+
+  /**
+   * Search messages
+   * 
+   * @param request - Message search request
+   * @returns Promise with search results
+   */
+  async search(request: MessageSearchRequest): Promise<MessageSearchResponse> {
+    return await transceivePost('entity.search', request);
+  },
+
+  /**
+   * Send a message
+   * 
+   * @param request - Message send request
+   * @returns Promise with send result
+   */
+  async send(request: MessageSendRequest): Promise<MessageSendResponse> {
+    return await transceivePost('entity.send', request);
+  },
+
+  /**
+   * Create a new message (draft)
+   * 
+   * @param request - Message create request
+   * @returns Promise with created message details
+   */
+  async create(request: MessageCreateRequest): Promise<MessageCreateResponse> {
+    return await transceivePost('entity.create', request);
+  },
+
+  /**
+   * Update an existing message (flags, labels, etc.)
+   * 
+   * @param request - Message update request
+   * @returns Promise with update result
+   */
+  async update(request: MessageUpdateRequest): Promise<MessageUpdateResponse> {
+    return await transceivePost('entity.update', request);
+  },
+
+  /**
+   * Delete/destroy a message
+   * 
+   * @param request - Message destroy request
+   * @returns Promise with destroy result
+   */
+  async destroy(request: MessageDestroyRequest): Promise<MessageDestroyResponse> {
+    return await transceivePost('entity.destroy', request);
+  },
+};
+
+export default entityService;

src/services/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Central export point for all Mail Manager services
+ */
+
+// Services
+export { providerService } from './providerService';
+export { serviceService } from './serviceService';
+export { collectionService } from './collectionService';
+export { entityService } from './entityService';
+
+// Type exports
+export type * from '../types/common';
+export type * from '../types/provider';
+export type * from '../types/service';
+export type * from '../types/collection';
+export type * from '../types/entity';

src/services/providerService.ts

@@ -0,0 +1,62 @@
+/**
+ * Provider management service
+ */
+
+import type {
+  ProviderListRequest,
+  ProviderListResponse,
+  ProviderExtantRequest,
+  ProviderExtantResponse,
+  ProviderFetchRequest,
+  ProviderFetchResponse, 
+} from '../types/provider';
+import { transceivePost } from './transceive';
+import { ProviderObject } from '../models/provider';
+
+
+export const providerService = {
+
+  /**
+   * List available providers
+   * 
+   * @param request - List request parameters
+   * 
+   * @returns Promise with provider object list keyed by provider identifier
+   */
+  async list(request: ProviderListRequest = {}): Promise<Record<string, ProviderObject>> {
+    const response = await transceivePost<ProviderListRequest, ProviderListResponse>('provider.list', request);
+    
+    // Convert response to ProviderObject instances
+    const list: Record<string, ProviderObject> = {};
+    Object.entries(response).forEach(([providerId, providerData]) => {
+      list[providerId] = new ProviderObject().fromJson(providerData);
+    });
+    
+    return list;
+  },
+
+  /**
+   * Fetch a specific provider
+   * 
+   * @param request - Fetch request parameters
+   * 
+   * @returns Promise with provider object
+   */
+  async fetch(request: ProviderFetchRequest): Promise<ProviderObject> {
+    const response = await transceivePost<ProviderFetchRequest, ProviderFetchResponse>('provider.fetch', request);
+    return new ProviderObject().fromJson(response);
+  },
+
+  /**
+   * Check which providers exist/are available
+   * 
+   * @param request - Extant request parameters
+   * 
+   * @returns Promise with provider availability status
+   */
+  async extant(request: ProviderExtantRequest): Promise<ProviderExtantResponse> {
+    return await transceivePost<ProviderExtantRequest, ProviderExtantResponse>('provider.extant', request);
+  },
+};
+
+export default providerService;

src/services/serviceService.ts

@@ -0,0 +1,154 @@
+/**
+ * Service management service
+ */
+
+import type {
+  ServiceListRequest,
+  ServiceListResponse,
+  ServiceExtantRequest,
+  ServiceExtantResponse,
+  ServiceFetchRequest,
+  ServiceFetchResponse,
+  ServiceDiscoverRequest,
+  ServiceDiscoverResponse,
+  ServiceTestRequest,
+  ServiceTestResponse,
+  ServiceInterface,
+  ServiceCreateResponse,
+  ServiceCreateRequest,
+  ServiceUpdateResponse,
+  ServiceUpdateRequest,
+} from '../types/service';
+import { transceivePost } from './transceive';
+import { ServiceObject } from '../models/service';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+
+/**
+ * Helper to create the right service model class based on provider
+ * Uses provider-specific factory if available, otherwise returns base ServiceObject
+ */
+function createServiceObject(data: ServiceInterface): ServiceObject {
+  const integrationStore = useIntegrationStore();
+  const factoryItem = integrationStore.getItemById('mail_service_factory', data.provider) as any;
+  const factory = factoryItem?.factory;
+  
+  // Use provider factory if available, otherwise base class
+  return factory ? factory(data) : new ServiceObject().fromJson(data);
+}
+
+export const serviceService = {
+
+  /**
+   * List available services
+   * 
+   * @param request - Service list request parameters
+   * 
+   * @returns Promise with service object list grouped by provider and keyed by service identifier
+   */
+  async list(request: ServiceListRequest = {}): Promise<Record<string, Record<string, ServiceObject>>> {
+    const response = await transceivePost<ServiceListRequest, ServiceListResponse>('service.list', request);
+    
+    // Convert nested response to ServiceObject instances
+    const list: Record<string, Record<string, ServiceObject>> = {};
+    Object.entries(response).forEach(([providerId, providerServices]) => {
+      list[providerId] = {};
+      Object.entries(providerServices).forEach(([serviceId, serviceData]) => {
+        list[providerId][serviceId] = createServiceObject(serviceData);
+      });
+    });
+    
+    return list;
+  },
+
+  /**
+   * Check which services exist/are available
+   * 
+   * @param request - Service extant request with source selector
+   * @returns Promise with service availability status
+   */
+  async extant(request: ServiceExtantRequest): Promise<ServiceExtantResponse> {
+    return await transceivePost<ServiceExtantRequest, ServiceExtantResponse>('service.extant', request);
+  },
+
+  /**
+   * Fetch a specific service
+   * 
+   * @param request - Service fetch request with provider and service IDs
+   * @returns Promise with service object
+   */
+  async fetch(request: ServiceFetchRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceFetchRequest, ServiceFetchResponse>('service.fetch', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Discover mail service configuration from identity
+   * 
+   * @param request - Discovery request with identity and optional hints
+   * @returns Promise with array of discovered services sorted by provider
+   */
+  async discover(request: ServiceDiscoverRequest): Promise<ServiceObject[]> {
+    const response = await transceivePost<ServiceDiscoverRequest, ServiceDiscoverResponse>('service.discover', request);
+    
+    // Convert discovery results to ServiceObjects
+    const services: ServiceObject[] = [];
+    Object.entries(response).forEach(([providerId, location]) => {
+      const serviceData: ServiceInterface = {
+        '@type': 'mail:service',
+        provider: providerId,
+        identifier: null,
+        label: null,
+        enabled: false,
+        location: location,
+      };
+      services.push(createServiceObject(serviceData));
+    });
+    
+    // Sort by provider
+    return services.sort((a, b) => a.provider.localeCompare(b.provider));
+  },
+
+  /**
+   * Test a mail service connection
+   * 
+   * @param request - Service test request
+   * @returns Promise with test results
+   */
+  async test(request: ServiceTestRequest): Promise<ServiceTestResponse> {
+    return await transceivePost<ServiceTestRequest, ServiceTestResponse>('service.test', request);
+  },
+
+  /**
+   * Create a new service
+   * 
+   * @param request - Service create request with provider ID and service data
+   * @returns Promise with created service object
+   */
+  async create(request: ServiceCreateRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceCreateRequest, ServiceCreateResponse>('service.create', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Update a existing service
+   * 
+   * @param request - Service update request with provider ID, service ID, and updated data
+   * @returns Promise with updated service object
+   */
+  async update(request: ServiceUpdateRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceUpdateRequest, ServiceUpdateResponse>('service.update', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Delete a service
+   * 
+   * @param request - Service delete request with provider ID and service ID
+   * @returns Promise with deletion result
+   */
+  async delete(request: { provider: string; identifier: string | number }): Promise<any> {
+    return await transceivePost('service.delete', request);
+  },
+};
+
+export default serviceService;

src/services/transceive.ts

@@ -0,0 +1,50 @@
+/**
+ * API Client for Mail Manager
+ * Provides a centralized way to make API calls with envelope wrapping/unwrapping
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+import type { ApiRequest, ApiResponse } from '../types/common';
+
+const fetchWrapper = createFetchWrapper();
+const API_URL = '/m/mail_manager/v1';
+const API_VERSION = 1;
+
+/**
+ * Generate a unique transaction ID
+ */
+export function generateTransactionId(): string {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Make an API call with automatic envelope wrapping and unwrapping
+ * 
+ * @param operation - Operation name (e.g., 'provider.list', 'service.autodiscover')
+ * @param data - Operation-specific request data
+ * @param user - Optional user identifier override
+ * @returns Promise with unwrapped response data
+ * @throws Error if the API returns an error status
+ */
+export async function transceivePost<TRequest, TResponse>(
+  operation: string,
+  data: TRequest,
+  user?: string
+): Promise<TResponse> {
+  const request: ApiRequest<TRequest> = {
+    version: API_VERSION,
+    transaction: generateTransactionId(),
+    operation,
+    data,
+    user
+  };
+  
+  const response: ApiResponse<TResponse> = await fetchWrapper.post(API_URL, request);
+  
+  if (response.status === 'error') {
+    const errorMessage = `[${operation}] ${response.data.message}${response.data.code ? ` (code: ${response.data.code})` : ''}`;
+    throw new Error(errorMessage);
+  }
+  
+  return response.data;
+}