mcp-creatio 0.4.0 → 0.5.0

package/src/creatio/services/configuration-service-provider.ts

@@ -1,127 +0,0 @@
-import {
-	CallConfigurationServiceRequest,
-	CallConfigurationServiceResult,
-	ConfigurationProvider,
-	ConfigurationServiceHttpMethod,
-	ConfigurationServiceQueryValue,
-} from '../providers';
-
-import { CreatioHttpClient } from './http-client';
-
-const VALID_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
-const METHODS_WITHOUT_BODY: ReadonlySet<ConfigurationServiceHttpMethod> = new Set([
-	'GET',
-	'DELETE',
-]);
-
-export class ConfigurationServiceProvider implements ConfigurationProvider {
-	private readonly _client: CreatioHttpClient;
-
-	public readonly kind = 'creatio-configuration-service';
-
-	constructor(client: CreatioHttpClient) {
-		this._client = client;
-	}
-
-	private _validateName(kind: 'service' | 'method', value: string): void {
-		if (!VALID_NAME_PATTERN.test(value)) {
-			throw new Error(`creatio_configuration_invalid_${kind}_name:${value}`);
-		}
-	}
-
-	private _buildQueryString(
-		query: Record<string, ConfigurationServiceQueryValue> | undefined,
-	): string {
-		if (!query) {
-			return '';
-		}
-		const params = new URLSearchParams();
-		for (const [key, value] of Object.entries(query)) {
-			params.append(key, String(value));
-		}
-		const serialized = params.toString();
-		return serialized ? `?${serialized}` : '';
-	}
-
-	private _buildUrl(request: CallConfigurationServiceRequest): string {
-		this._validateName('service', request.service);
-		this._validateName('method', request.method);
-		const base = `${this._client.normalizedBaseUrl}/0/rest/${request.service}/${request.method}`;
-		return `${base}${this._buildQueryString(request.query)}`;
-	}
-
-	private async _buildRequestInit(
-		httpMethod: ConfigurationServiceHttpMethod,
-		body: unknown,
-	): Promise<RequestInit> {
-		const includeBody = !METHODS_WITHOUT_BODY.has(httpMethod) && body !== undefined;
-		const headers = includeBody
-			? await this._client.getPostHeaders()
-			: await this._client.getJsonHeaders();
-		const init: RequestInit = { method: httpMethod, headers };
-		if (includeBody) {
-			init.body = JSON.stringify(body);
-		}
-		return init;
-	}
-
-	private async _parseResponseBody(response: Response): Promise<{
-		body: unknown;
-		contentType?: string;
-	}> {
-		const contentType = response.headers.get('content-type') ?? undefined;
-		const text = await response.text();
-		if (!text) {
-			return contentType !== undefined ? { body: null, contentType } : { body: null };
-		}
-		if (contentType && contentType.toLowerCase().includes('application/json')) {
-			try {
-				return { body: JSON.parse(text), contentType };
-			} catch {
-				return { body: text, contentType };
-			}
-		}
-		return contentType !== undefined ? { body: text, contentType } : { body: text };
-	}
-
-	public async call(
-		request: CallConfigurationServiceRequest,
-	): Promise<CallConfigurationServiceResult> {
-		const httpMethod: ConfigurationServiceHttpMethod = request.httpMethod ?? 'POST';
-		const url = this._buildUrl(request);
-		const operation = `call-configuration-service:${request.service}.${request.method}`;
-		return this._client.executeWithTiming(
-			operation,
-			url,
-			async () => {
-				const init = await this._buildRequestInit(httpMethod, request.body);
-				return this._client.fetchWithAuth(url, async () => init);
-			},
-			async (response, duration) => {
-				const { body, contentType } = await this._parseResponseBody(response);
-				this._client.logSuccess(operation, response.status, duration, {
-					httpMethod,
-					service: request.service,
-					method: request.method,
-				});
-				const result: CallConfigurationServiceResult = {
-					status: response.status,
-					body,
-				};
-				if (contentType !== undefined) {
-					result.contentType = contentType;
-				}
-				return result;
-			},
-			async (response, duration) =>
-				this._client.handleErrorResponse(
-					operation,
-					response,
-					duration,
-					'creatio_configuration_service_failed',
-					{ url, httpMethod },
-				),
-			{ httpMethod, service: request.service, method: request.method },
-		);
-	}
-}

package/src/creatio/services/creatio-service-context.ts

@@ -1,55 +0,0 @@
-import { CreatioAuthManager, ICreatioAuthProvider } from '../auth';
-import { CreatioClientConfig } from '../client-config';
-import { CreatioProviderContext } from '../provider-context';
-import {
-	AdminOperationProvider,
-	ConfigurationProvider,
-	CrudProvider,
-	FeatureProvider,
-	ProcessProvider,
-	SysSettingsProvider,
-	UserProvider,
-} from '../providers';
-
-import { AdminOperationServiceProvider } from './admin-operation-service-provider';
-import { ConfigurationServiceProvider } from './configuration-service-provider';
-import { FeatureServiceProvider } from './feature-service-provider';
-import { CreatioHttpClient } from './http-client';
-import { ODataMetadataStore } from './metadata-store';
-import { ODataCrudProvider } from './odata-crud-provider';
-import { ProcessServiceProvider } from './process-service-provider';
-import { SysSettingsServiceProvider } from './sys-settings-service-provider';
-import { UserInfoProvider } from './user-info-provider';
-
-export class CreatioServiceContext implements CreatioProviderContext {
-	private readonly _config: CreatioClientConfig;
-	private readonly _authManager: CreatioAuthManager;
-	private readonly _httpClient: CreatioHttpClient;
-
-	public readonly kind = 'creatio-services';
-	public readonly adminOperation: AdminOperationProvider;
-	public readonly configuration: ConfigurationProvider;
-	public readonly crud: CrudProvider;
-	public readonly feature: FeatureProvider;
-	public readonly process: ProcessProvider;
-	public readonly sysSettings: SysSettingsProvider;
-	public readonly user: UserProvider;
-
-	public get authProvider(): ICreatioAuthProvider {
-		return this._authManager.getProvider();
-	}
-
-	constructor(config: CreatioClientConfig) {
-		this._config = config;
-		this._authManager = new CreatioAuthManager(this._config);
-		this._httpClient = new CreatioHttpClient(this._config, this._authManager);
-		const metadataStore = new ODataMetadataStore(this._httpClient);
-		this.adminOperation = new AdminOperationServiceProvider(this._httpClient);
-		this.configuration = new ConfigurationServiceProvider(this._httpClient);
-		this.crud = new ODataCrudProvider(this._httpClient, metadataStore);
-		this.feature = new FeatureServiceProvider(this._httpClient);
-		this.process = new ProcessServiceProvider(this._httpClient);
-		this.sysSettings = new SysSettingsServiceProvider(this._httpClient);
-		this.user = new UserInfoProvider(this._httpClient);
-	}
-}

package/src/creatio/services/feature-service-provider.ts

@@ -1,60 +0,0 @@
-import { ClearFeatureCacheResult, FeatureProvider } from '../providers';
-
-import { CreatioHttpClient } from './http-client';
-
-export class FeatureServiceProvider implements FeatureProvider {
-	private readonly _client: CreatioHttpClient;
-
-	public readonly kind = 'creatio-feature-service';
-
-	constructor(client: CreatioHttpClient) {
-		this._client = client;
-	}
-
-	private _getClearCacheUrl(featureCode?: string): string {
-		const base = `${this._client.normalizedBaseUrl}/0/rest/FeatureService/ClearFeaturesCacheForAllUsers`;
-		if (!featureCode) {
-			return `${base}/`;
-		}
-		const encoded = Buffer.from(featureCode, 'utf8').toString('base64');
-		return `${base}/${encoded}`;
-	}
-
-	public async clearFeaturesCache(featureCode?: string): Promise<ClearFeatureCacheResult> {
-		const url = this._getClearCacheUrl(featureCode);
-		return this._client.executeWithTiming(
-			'clear-features-cache',
-			url,
-			async () => {
-				const headers = await this._client.getJsonHeaders();
-				return this._client.fetchWithAuth(url, async () => ({
-					method: 'GET',
-					headers,
-				}));
-			},
-			async (response, duration) => {
-				const message = await response.text();
-				this._client.logSuccess('clear-features-cache', response.status, duration, {
-					featureCode: featureCode ?? '(all)',
-				});
-				const result: ClearFeatureCacheResult = { success: true, message };
-				if (featureCode !== undefined) {
-					result.featureCode = featureCode;
-				}
-				return result;
-			},
-			async (response, duration) =>
-				this._client.handleErrorResponse(
-					'clear-features-cache',
-					response,
-					duration,
-					'creatio_clear_features_cache_failed',
-					{
-						featureCode: featureCode ?? '(all)',
-						url,
-					},
-				),
-			{ featureCode: featureCode ?? '(all)' },
-		);
-	}
-}

package/src/creatio/services/http-client.ts

@@ -1,174 +0,0 @@
-import log from '../../log';
-import { JSON_ACCEPT, XML_ACCEPT } from '../../types';
-import { CreatioAuthManager, ICreatioAuthProvider } from '../auth';
-import { CreatioClientConfig } from '../client-config';
-
-type RequestFactory = () => Promise<RequestInit>;
-type SuccessHandler<T> = (response: Response, duration: number) => Promise<T>;
-type ErrorHandler<T> = (response: Response, duration: number) => Promise<T>;
-
-type LogContext = Record<string, any>;
-
-export class CreatioHttpClient {
-	private readonly _config: CreatioClientConfig;
-	private readonly _authManager: CreatioAuthManager;
-	private readonly _normalizedBaseUrl: string;
-
-	public get authProvider(): ICreatioAuthProvider {
-		return this._authManager.getProvider();
-	}
-
-	public get normalizedBaseUrl(): string {
-		return this._normalizedBaseUrl;
-	}
-
-	public get odataRoot(): string {
-		return `${this._normalizedBaseUrl}/0/odata`;
-	}
-
-	constructor(config: CreatioClientConfig, authManager: CreatioAuthManager) {
-		this._config = config;
-		this._authManager = authManager;
-		this._normalizedBaseUrl = this._config.baseUrl.replace(/\/$/, '');
-	}
-
-	private _logRequest(url: string, requestInit: RequestInit): void {
-		log.info('creatio.http.request', {
-			url,
-			method: requestInit.method || 'GET',
-			hasAuth: Boolean(requestInit.headers && (requestInit.headers as any)['Authorization']),
-		});
-	}
-
-	private _logUnauthorizedResponse(
-		url: string,
-		response: Response,
-		hasTriedRefresh: boolean,
-	): void {
-		log.warn('creatio.http.401_response', {
-			url,
-			status: response.status,
-			triedRefresh: hasTriedRefresh,
-			responseHeaders: Object.fromEntries(response.headers.entries()),
-		});
-	}
-
-	public async getJsonHeaders(): Promise<Record<string, string>> {
-		return this.authProvider.getHeaders(JSON_ACCEPT, true);
-	}
-
-	public async getXmlHeaders(): Promise<Record<string, string>> {
-		return this.authProvider.getHeaders(XML_ACCEPT, false);
-	}
-
-	public async getPostHeaders(): Promise<Record<string, string>> {
-		const headers = await this.getJsonHeaders();
-		return {
-			...headers,
-			'Content-Type': 'application/json',
-		};
-	}
-
-	public async createPostRequest(body?: any): Promise<RequestInit> {
-		const headers = await this.getPostHeaders();
-		return {
-			method: 'POST',
-			headers,
-			body: body ? JSON.stringify(body) : JSON.stringify({}),
-		};
-	}
-
-	public async fetchJson(url: string, initFactory: RequestFactory) {
-		const response = await this.fetchWithAuth(url, initFactory);
-		if (!response.ok) {
-			const errorText = await response.text().catch(() => '');
-			throw new Error(`creatio_http_error:${response.status} ${errorText}`);
-		}
-		return response.json();
-	}
-
-	public async fetchText(url: string, initFactory: RequestFactory) {
-		const response = await this.fetchWithAuth(url, initFactory);
-		if (!response.ok) {
-			const errorText = await response.text().catch(() => '');
-			throw new Error(`creatio_http_error:${response.status} ${errorText}`);
-		}
-		return response.text();
-	}
-
-	public async fetchWithAuth(url: string, initFactory: RequestFactory): Promise<Response> {
-		let hasTriedRefresh = false;
-		while (true) {
-			const requestInit = await initFactory();
-			this._logRequest(url, requestInit);
-			const response = await fetch(url, requestInit);
-			if (response.status !== 401) {
-				return response;
-			}
-			this._logUnauthorizedResponse(url, response, hasTriedRefresh);
-			if (hasTriedRefresh) {
-				return response;
-			}
-			hasTriedRefresh = true;
-			await this.authProvider.refresh();
-		}
-	}
-
-	public async executeWithTiming<T>(
-		operation: string,
-		url: string,
-		request: () => Promise<Response>,
-		successHandler: SuccessHandler<T>,
-		errorHandler: ErrorHandler<T>,
-		logContext: LogContext = {},
-	): Promise<T> {
-		const startTime = Date.now();
-		try {
-			const response = await request();
-			const duration = Date.now() - startTime;
-			if (!response.ok) {
-				return await errorHandler(response, duration);
-			}
-			return await successHandler(response, duration);
-		} catch (error: any) {
-			const duration = Date.now() - startTime;
-			log.error(`creatio.http.${operation}.error`, {
-				...logContext,
-				url,
-				error: String(error?.message ?? error),
-				duration,
-			});
-			throw error;
-		}
-	}
-
-	public async handleErrorResponse(
-		operation: string,
-		response: Response,
-		duration: number,
-		errorPrefix: string,
-		logContext: LogContext = {},
-	): Promise<never> {
-		const errorText = await response.text().catch(() => '');
-		log.error(`creatio.http.${operation}.error`, {
-			...logContext,
-			status: response.status,
-			error: errorText,
-			duration,
-		});
-		throw new Error(`${errorPrefix}:${response.status} ${errorText}`);
-	}
-
-	public logSuccess(
-		operation: string,
-		status: number,
-		duration: number,
-		logContext: LogContext = {},
-	) {
-		log.info(`creatio.http.${operation}.success`, {
-			...logContext,
-			status,
-			duration,
-		});
-	}
-}

package/src/creatio/services/index.ts

@@ -1,10 +0,0 @@
-export * from './admin-operation-service-provider';
-export * from './configuration-service-provider';
-export * from './creatio-service-context';
-export * from './feature-service-provider';
-export * from './http-client';
-export * from './metadata-store';
-export * from './odata-crud-provider';
-export * from './process-service-provider';
-export * from './sys-settings-service-provider';
-export * from './user-info-provider';

package/src/creatio/services/metadata-store.ts

@@ -1,181 +0,0 @@
-import { XMLParser } from 'fast-xml-parser';
-
-import log from '../../log';
-import { EntitySchemaDescription } from '../providers';
-
-import { CreatioHttpClient } from './http-client';
-
-export class ODataMetadataStore {
-	private readonly _client: CreatioHttpClient;
-	private _metadataXml?: string;
-	private _metadataParsed?: any;
-
-	constructor(client: CreatioHttpClient) {
-		this._client = client;
-	}
-
-	private _arrayify<T>(value: T | T[] | undefined | null): T[] {
-		if (value == null) {
-			return [];
-		}
-		return Array.isArray(value) ? value : [value];
-	}
-
-	private async _getMetadataXml(): Promise<string> {
-		if (this._metadataXml) {
-			return this._metadataXml;
-		}
-		const headers = await this._client.getXmlHeaders();
-		const metadataUrl = `${this._client.odataRoot}/$metadata`;
-		const xmlContent = await this._client.fetchText(metadataUrl, async () => ({ headers }));
-		this._metadataXml = xmlContent;
-		return this._metadataXml;
-	}
-
-	private async _getParsedMetadata(): Promise<any> {
-		if (this._metadataParsed) {
-			return this._metadataParsed;
-		}
-		const xmlContent = await this._getMetadataXml();
-		const parser = new XMLParser({
-			ignoreAttributes: false,
-			attributeNamePrefix: '@_',
-		});
-		this._metadataParsed = parser.parse(xmlContent);
-		return this._metadataParsed;
-	}
-
-	private _extractSchemas(metadata: any): any[] {
-		const dataServices = metadata['edmx:Edmx']?.['edmx:DataServices'];
-		return this._arrayify<any>(dataServices?.Schema);
-	}
-
-	private async _tryGetEntitySetsFromService(): Promise<string[] | null> {
-		try {
-			const serviceUrl = `${this._client.odataRoot}/`;
-			const headers = await this._client.getJsonHeaders();
-			const response = await this._client.fetchWithAuth(serviceUrl, async () => ({
-				headers,
-			}));
-			if (response.ok) {
-				const body: any = await response.json().catch(() => null);
-				if (body && Array.isArray(body.value)) {
-					return body.value.map((item: any) => String(item.name));
-				}
-			}
-			if (!response.ok) {
-				log.error('creatio.metadata.list_entity_sets.error', {
-					url: serviceUrl,
-					status: response.status,
-				});
-			}
-		} catch (error: any) {
-			log.error('creatio.metadata.list_entity_sets.error', {
-				url: `${this._client.odataRoot}/`,
-				error: String(error?.message ?? error),
-			});
-		}
-		return null;
-	}
-
-	private async _getEntitySetsFromMetadata(): Promise<string[]> {
-		const metadata = await this._getParsedMetadata();
-		const schemas = this._extractSchemas(metadata);
-		const entitySets: string[] = [];
-		for (const schema of schemas) {
-			const containers = this._arrayify<any>(schema.EntityContainer);
-			for (const container of containers) {
-				const sets = this._arrayify<any>(container.EntitySet);
-				for (const set of sets) {
-					const name = set?.['@_Name'];
-					if (name) {
-						entitySets.push(String(name));
-					}
-				}
-			}
-		}
-		return Array.from(new Set(entitySets));
-	}
-
-	private _findEntityType(schemas: any[], entitySet: string): string {
-		for (const schema of schemas) {
-			const containers = this._arrayify<any>(schema.EntityContainer);
-			for (const container of containers) {
-				const sets = this._arrayify<any>(container.EntitySet);
-				for (const set of sets) {
-					if (set?.['@_Name'] === entitySet) {
-						return String(set?.['@_EntityType'] ?? '');
-					}
-				}
-			}
-		}
-		return '';
-	}
-
-	private _findEntityTypeNode(schemas: any[], typeName: string): any {
-		for (const schema of schemas) {
-			const types = this._arrayify<any>(schema.EntityType);
-			for (const type of types) {
-				if (type?.['@_Name'] === typeName) {
-					return type;
-				}
-			}
-		}
-		return undefined;
-	}
-
-	private _parseEntityProperties(entityTypeNode: any): {
-		key: string[];
-		properties: Array<{
-			name: string;
-			type: string;
-			nullable?: boolean;
-		}>;
-	} {
-		const keyRefs = this._arrayify<any>(entityTypeNode.Key?.PropertyRef);
-		const key = keyRefs.map((ref) => String(ref?.['@_Name'] ?? '')).filter(Boolean) as string[];
-		const propertyNodes = this._arrayify<any>(entityTypeNode.Property);
-		const properties = propertyNodes.map((prop) => {
-			const name = String(prop?.['@_Name'] ?? '');
-			const type = String(prop?.['@_Type'] ?? '');
-			const result: {
-				name: string;
-				type: string;
-				nullable?: boolean;
-			} = { name, type };
-			if (Object.prototype.hasOwnProperty.call(prop, '@_Nullable')) {
-				result.nullable = String(prop['@_Nullable']) === 'true';
-			}
-			return result;
-		});
-		return { key, properties };
-	}
-
-	public async listEntitySets(): Promise<string[]> {
-		const serviceSets = await this._tryGetEntitySetsFromService();
-		if (serviceSets) {
-			return serviceSets;
-		}
-		return this._getEntitySetsFromMetadata();
-	}
-
-	public async describeEntity(entitySet: string): Promise<EntitySchemaDescription> {
-		const metadata = await this._getParsedMetadata();
-		const schemas = this._extractSchemas(metadata);
-		const fullType = this._findEntityType(schemas, entitySet);
-		if (!fullType) {
-			const error = `entity_not_found:${entitySet}`;
-			log.error('creatio.metadata.describe_entity.error', { entitySet, error });
-			throw new Error(error);
-		}
-		const typeName = fullType.split('.').pop()!;
-		const entityTypeNode = this._findEntityTypeNode(schemas, typeName);
-		if (!entityTypeNode) {
-			const error = `entity_type_not_found:${typeName}`;
-			log.error('creatio.metadata.describe_entity.error', { entitySet, error });
-			throw new Error(error);
-		}
-		const { key, properties } = this._parseEntityProperties(entityTypeNode);
-		return { entitySet, entityType: typeName, key, properties };
-	}
-}