Initial commit

src/services/collectionService.ts

@@ -0,0 +1,88 @@
+/**
+ * Collection management service
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+
+const fetchWrapper = createFetchWrapper();
+import type {
+  CollectionListRequest,
+  CollectionListResponse,
+  CollectionExtantRequest,
+  CollectionExtantResponse,
+  CollectionFetchRequest,
+  CollectionFetchResponse,
+  CollectionCreateRequest,
+  CollectionCreateResponse,
+  CollectionModifyRequest,
+  CollectionModifyResponse,
+  CollectionDestroyRequest,
+  CollectionDestroyResponse,
+} from '../types/collection';
+
+const BASE_URL = '/m/chrono_manager/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 fetchWrapper.post(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/extant`, request);
+  },
+
+  /**
+   * Fetch a specific collection
+   * 
+   * @param request - Collection fetch request
+   * @returns Promise with collection details
+   */
+  async fetch(request: CollectionFetchRequest): Promise<CollectionFetchResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/fetch`, request);
+  },
+
+  /**
+   * Create a new collection
+   * 
+   * @param request - Collection create request
+   * @returns Promise with created collection
+   */
+  async create(request: CollectionCreateRequest): Promise<CollectionCreateResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/create`, request);
+  },
+
+  /**
+   * Modify an existing collection
+   * 
+   * @param request - Collection modify request
+   * @returns Promise with modified collection
+   */
+  async modify(request: CollectionModifyRequest): Promise<CollectionModifyResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/modify`, request);
+  },
+
+  /**
+   * Delete a collection
+   * 
+   * @param request - Collection destroy request
+   * @returns Promise with deletion result
+   */
+  async destroy(request: CollectionDestroyRequest): Promise<CollectionDestroyResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/destroy`, request);
+  },
+};
+
+export default collectionService;

src/services/entityService.ts

@@ -0,0 +1,100 @@
+/**
+ * Entity management service
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+
+const fetchWrapper = createFetchWrapper();
+import type {
+  EntityListRequest,
+  EntityListResponse,
+  EntityDeltaRequest,
+  EntityDeltaResponse,
+  EntityExtantRequest,
+  EntityExtantResponse,
+  EntityFetchRequest,
+  EntityFetchResponse,
+  EntityCreateRequest,
+  EntityCreateResponse,
+  EntityModifyRequest,
+  EntityModifyResponse,
+  EntityDestroyRequest,
+  EntityDestroyResponse,
+} from '../types/entity';
+
+const BASE_URL = '/m/chrono_manager/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 fetchWrapper.post(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/extant`, request);
+  },
+
+  /**
+   * Fetch specific entities
+   * 
+   * @param request - Entity fetch request
+   * @returns Promise with entity details
+   */
+  async fetch(request: EntityFetchRequest): Promise<EntityFetchResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/fetch`, request);
+  },
+
+  /**
+   * Create a new entity
+   * 
+   * @param request - Entity create request
+   * @returns Promise with created entity
+   */
+  async create(request: EntityCreateRequest): Promise<EntityCreateResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/create`, request);
+  },
+
+  /**
+   * Modify an existing entity
+   * 
+   * @param request - Entity modify request
+   * @returns Promise with modified entity
+   */
+  async modify(request: EntityModifyRequest): Promise<EntityModifyResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/modify`, request);
+  },
+
+  /**
+   * Delete an entity
+   * 
+   * @param request - Entity destroy request
+   * @returns Promise with deletion result
+   */
+  async destroy(request: EntityDestroyRequest): Promise<EntityDestroyResponse> {
+    return await fetchWrapper.post(`${BASE_URL}/destroy`, request);
+  },
+};
+
+export default entityService;

src/services/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Central export point for all Chrono 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,36 @@
+/**
+ * Provider management service
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+
+const fetchWrapper = createFetchWrapper();
+import type { ProviderListResponse, ProviderExtantResponse } from '../types/provider';
+import type { SourceSelector } from '../types/common';
+
+const BASE_URL = '/m/chrono_manager/provider';
+
+export const providerService = {
+
+  /**
+   * List all available providers
+   * 
+   * @returns Promise with provider list keyed by provider ID
+   */
+  async list(): Promise<ProviderListResponse> {
+    return await fetchWrapper.get(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/extant`, { sources });
+  },
+};
+
+export default providerService;

src/services/serviceService.ts

@@ -0,0 +1,52 @@
+/**
+ * Service management service
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+
+const fetchWrapper = createFetchWrapper();
+import type {
+  ServiceListRequest,
+  ServiceListResponse,
+  ServiceExtantRequest,
+  ServiceExtantResponse,
+  ServiceFetchRequest,
+  ServiceFetchResponse,
+} from '../types/service';
+
+const BASE_URL = '/m/chrono_manager/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 fetchWrapper.post(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/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 fetchWrapper.post(`${BASE_URL}/fetch`, request);
+  },
+};
+
+export default serviceService;