mcp-creatio 0.3.8 → 0.4.0

package/src/creatio/services/admin-operation-service-provider.ts

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+	AdminOperationProvider,
+	AdminOperationServiceResult,
+	SetAdminOperationGranteeRequest,
+	UpsertAdminOperationRequest,
+	UpsertAdminOperationResult,
+} from '../providers';
+
+import { CreatioHttpClient } from './http-client';
+
+const EMPTY_GUID = '00000000-0000-0000-0000-000000000000';
+
+interface RightsHelperInner {
+	Success: boolean;
+	ExMessage?: string;
+}
+
+export class AdminOperationServiceProvider implements AdminOperationProvider {
+	private readonly _client: CreatioHttpClient;
+
+	public readonly kind = 'creatio-admin-operation-service';
+
+	constructor(client: CreatioHttpClient) {
+		this._client = client;
+	}
+
+	private _getMethodUrl(method: string): string {
+		return `${this._client.normalizedBaseUrl}/0/rest/RightsService/${method}`;
+	}
+
+	private _parseRightsResponse(method: string, body: any): RightsHelperInner {
+		const resultKey = `${method}Result`;
+		const wrapped = body?.[resultKey];
+		if (typeof wrapped !== 'string') {
+			throw new Error(
+				`creatio_rights_service_unexpected_response:${method}:${JSON.stringify(body)}`,
+			);
+		}
+		return JSON.parse(wrapped) as RightsHelperInner;
+	}
+
+	private async _callRightsService(
+		method: string,
+		payload: Record<string, unknown>,
+	): Promise<AdminOperationServiceResult> {
+		const url = this._getMethodUrl(method);
+		return this._client.executeWithTiming(
+			method,
+			url,
+			async () => {
+				const requestInit = await this._client.createPostRequest(payload);
+				return this._client.fetchWithAuth(url, async () => requestInit);
+			},
+			async (response, duration) => {
+				const body = await response.json();
+				const inner = this._parseRightsResponse(method, body);
+				const success = Boolean(inner.Success);
+				this._client.logSuccess(method, response.status, duration, {
+					rightsServiceSuccess: success,
+				});
+				const result: AdminOperationServiceResult = { success };
+				if (inner.ExMessage !== undefined && inner.ExMessage !== '') {
+					result.exMessage = inner.ExMessage;
+				}
+				return result;
+			},
+			async (response, duration) =>
+				this._client.handleErrorResponse(
+					method,
+					response,
+					duration,
+					`creatio_${method.toLowerCase()}_failed`,
+					{ url },
+				),
+			{ method },
+		);
+	}
+
+	public async upsertAdminOperation(
+		request: UpsertAdminOperationRequest,
+	): Promise<UpsertAdminOperationResult> {
+		const recordId = request.id && request.id !== EMPTY_GUID ? request.id : randomUUID();
+		const payload = {
+			recordId,
+			name: request.name,
+			code: request.code,
+			description: request.description ?? '',
+		};
+		const base = await this._callRightsService('UpsertAdminOperation', payload);
+		const result: UpsertAdminOperationResult = { ...base, id: recordId };
+		return result;
+	}
+
+	public async deleteAdminOperation(recordIds: string[]): Promise<AdminOperationServiceResult> {
+		return this._callRightsService('DeleteAdminOperation', { recordIds });
+	}
+
+	public async setAdminOperationGrantee(
+		request: SetAdminOperationGranteeRequest,
+	): Promise<AdminOperationServiceResult> {
+		return this._callRightsService('SetAdminOperationGrantee', {
+			adminOperationId: request.adminOperationId,
+			adminUnitIds: request.adminUnitIds,
+			canExecute: request.canExecute,
+		});
+	}
+
+	public async deleteAdminOperationGrantee(
+		recordIds: string[],
+	): Promise<AdminOperationServiceResult> {
+		return this._callRightsService('DeleteAdminOperationGrantee', { recordIds });
+	}
+}

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

@@ -0,0 +1,127 @@
+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,8 +1,19 @@
 import { CreatioAuthManager, ICreatioAuthProvider } from '../auth';
 import { CreatioClientConfig } from '../client-config';
 import { CreatioProviderContext } from '../provider-context';
-import { CrudProvider, ProcessProvider, SysSettingsProvider, UserProvider } from '../providers';
+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';
@@ -16,7 +27,10 @@ export class CreatioServiceContext implements CreatioProviderContext {
 	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;
@@ -30,7 +44,10 @@ export class CreatioServiceContext implements CreatioProviderContext {
 		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

@@ -0,0 +1,60 @@
+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/index.ts

@@ -1,4 +1,7 @@
+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';