Initial commit

2025-12-21 09:53:16 -05:00
commit a7ccac98a2
43 changed files with 6391 additions and 0 deletions
@@ -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('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('collection.fetch', request);
+  },
+
+  /**
+   * Create a new collection
+   * 
+   * @param request - Collection create request
+   * @returns Promise with created collection
+   */
+  async create(request: CollectionCreateRequest): Promise<CollectionCreateResponse> {
+    return await transceivePost('collection.create', request);
+  },
+
+  /**
+   * Modify an existing collection
+   * 
+   * @param request - Collection modify request
+   * @returns Promise with modified collection
+   */
+  async modify(request: CollectionModifyRequest): Promise<CollectionModifyResponse> {
+    return await transceivePost('collection.modify', request);
+  },
+
+  /**
+   * Delete a collection
+   * 
+   * @param request - Collection destroy request
+   * @returns Promise with deletion result
+   */
+  async destroy(request: CollectionDestroyRequest): Promise<CollectionDestroyResponse> {
+    return await transceivePost('collection.destroy', request);
+  },
+};
+
+export default collectionService;
@@ -0,0 +1,96 @@
+/**
+ * Entity management service
+ */
+
+import { transceivePost } from './transceive';
+import type {
+  EntityListRequest,
+  EntityListResponse,
+  EntityDeltaRequest,
+  EntityDeltaResponse,
+  EntityExtantRequest,
+  EntityExtantResponse,
+  EntityFetchRequest,
+  EntityFetchResponse,
+  EntityCreateRequest,
+  EntityCreateResponse,
+  EntityModifyRequest,
+  EntityModifyResponse,
+  EntityDestroyRequest,
+  EntityDestroyResponse,
+} from '../types/entity';
+
+export const entityService = {
+
+  /**
+   * List all available entities (events, tasks, journals)
+   * 
+   * @param request - Entity list request parameters
+   * @returns Promise with entity list grouped by provider, service, and collection
+   */
+  async list(request: EntityListRequest = {}): Promise<EntityListResponse> {
+    return await transceivePost<EntityListRequest, EntityListResponse>('entity.list', request);
+  },
+
+  /**
+   * Get delta changes for entities
+   * 
+   * @param request - Entity delta request with source selector
+   * @returns Promise with delta changes (created, modified, deleted)
+   */
+  async delta(request: EntityDeltaRequest): Promise<EntityDeltaResponse> {
+    return await transceivePost('entity.delta', request);
+  },
+
+  /**
+   * Check which entities exist/are available
+   * 
+   * @param request - Entity extant request with source selector
+   * @returns Promise with entity availability status
+   */
+  async extant(request: EntityExtantRequest): Promise<EntityExtantResponse> {
+    return await transceivePost('entity.extant', request);
+  },
+
+  /**
+   * Fetch specific entities
+   * 
+   * @param request - Entity fetch request
+   * @returns Promise with entity details
+   */
+  async fetch(request: EntityFetchRequest): Promise<EntityFetchResponse> {
+    return await transceivePost('entity.fetch', request);
+  },
+
+  /**
+   * Create a new entity
+   * 
+   * @param request - Entity create request
+   * @returns Promise with created entity
+   */
+  async create(request: EntityCreateRequest): Promise<EntityCreateResponse> {
+    return await transceivePost('entity.create', request);
+  },
+
+  /**
+   * Modify an existing entity
+   * 
+   * @param request - Entity modify request
+   * @returns Promise with modified entity
+   */
+  async modify(request: EntityModifyRequest): Promise<EntityModifyResponse> {
+    return await transceivePost('entity.modify', request);
+  },
+
+  /**
+   * Delete an entity
+   * 
+   * @param request - Entity destroy request
+   * @returns Promise with deletion result
+   */
+  async destroy(request: EntityDestroyRequest): Promise<EntityDestroyResponse> {
+    return await transceivePost('entity.destroy', request);
+  },
+};
+
+export default entityService;
@@ -0,0 +1,16 @@
+/**
+ * Central export point for all People 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';
@@ -0,0 +1,32 @@
+/**
+ * Provider management service
+ */
+
+import { transceivePost } from './transceive';
+import type { ProviderListResponse, ProviderExtantResponse } from '../types/provider';
+import type { SourceSelector } from '../types/common';
+
+export const providerService = {
+
+  /**
+   * List all available providers
+   * 
+   * @returns Promise with provider list keyed by provider ID
+   */
+  async list(): Promise<ProviderListResponse> {
+    return await transceivePost<{}, ProviderListResponse>('provider.list', {});
+  },
+
+  /**
+   * Check which providers exist/are available
+   * 
+   * @param sources - Source selector with provider IDs to check
+   * 
+   * @returns Promise with provider availability status
+   */
+  async extant(sources: SourceSelector): Promise<ProviderExtantResponse> {
+    return await transceivePost('provider.extant', { sources });
+  },
+};
+
+export default providerService;
@@ -0,0 +1,48 @@
+/**
+ * Service management service
+ */
+
+import { transceivePost } from './transceive';
+import type {
+  ServiceListRequest,
+  ServiceListResponse,
+  ServiceExtantRequest,
+  ServiceExtantResponse,
+  ServiceFetchRequest,
+  ServiceFetchResponse,
+} from '../types/service';
+
+export const serviceService = {
+
+  /**
+   * List all available services
+   * 
+   * @param request - Service list request parameters
+   * @returns Promise with service list grouped by provider
+   */
+  async list(request: ServiceListRequest = {}): Promise<ServiceListResponse> {
+    return await transceivePost<ServiceListRequest, ServiceListResponse>('service.list', request);
+  },
+
+  /**
+   * 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('service.extant', request);
+  },
+
+  /**
+   * Fetch a specific service
+   * 
+   * @param request - Service fetch request with provider and service IDs
+   * @returns Promise with service details
+   */
+  async fetch(request: ServiceFetchRequest): Promise<ServiceFetchResponse> {
+    return await transceivePost('service.fetch', request);
+  },
+};
+
+export default serviceService;
@@ -0,0 +1,50 @@
+/**
+ * API Client for People 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/people_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', 'collection.fetch')
+ * @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;
+}