@nest-omni/core 3.1.2-7 → 3.1.2-9

package/http-client/examples/basic-usage.example.d.ts

@@ -0,0 +1,53 @@
+import { HttpClientService, HttpLogQueryService } from '../services';
+import { HttpLogQueryOptions } from '../entities';
+export declare class BasicHttpExample {
+    private readonly httpClient;
+    private readonly logQueryService;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService);
+    getUser(id: string): Promise<any>;
+    searchUsers(query: string, page?: number, limit?: number): Promise<any>;
+    createUser(userData: any): Promise<any>;
+    updateUser(id: string, userData: any): Promise<any>;
+    deleteUser(id: string): Promise<any>;
+    uploadFile(file: Buffer, filename: string): Promise<any>;
+    customRequest(): Promise<any>;
+    getStatistics(): any;
+    resetStatistics(): void;
+    generateCurlForRequest(url: string, method?: string, data?: any): string;
+    queryHttpLogs(options?: HttpLogQueryOptions): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findErrorLogs(limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findSlowRequests(minResponseTime?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findRetryLogs(minRetries?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findLogsByServiceName(serviceName: string, limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findLogsByOperationName(operationName: string, limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    getHttpStats(startDate?: Date, endDate?: Date): Promise<import("../entities").HttpLogStats>;
+    findLogByRequestId(requestId: string): Promise<import("../entities").HttpLogEntity>;
+    cleanupOldLogs(daysToKeep?: number): Promise<number>;
+}

package/http-client/examples/basic-usage.example.js

@@ -0,0 +1,161 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicHttpExample = void 0;
+const common_1 = require("@nestjs/common");
+const services_1 = require("../services");
+let BasicHttpExample = class BasicHttpExample {
+    constructor(httpClient, logQueryService) {
+        this.httpClient = httpClient;
+        this.logQueryService = logQueryService;
+    }
+    getUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${id}`);
+        });
+    }
+    searchUsers(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, page = 1, limit = 10) {
+            return this.httpClient.get('/users', {
+                params: {
+                    q: query,
+                    page,
+                    limit,
+                },
+            });
+        });
+    }
+    createUser(userData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/users', userData, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        });
+    }
+    updateUser(id, userData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.put(`/users/${id}`, userData);
+        });
+    }
+    deleteUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.delete(`/users/${id}`);
+        });
+    }
+    uploadFile(file, filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append('file', new Blob([new Uint8Array(file)], { type: 'application/octet-stream' }), filename);
+            return this.httpClient.post('/upload', formData, {
+                headers: {
+                    'Content-Type': 'multipart/form-data',
+                },
+            });
+        });
+    }
+    customRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.request({
+                method: 'PATCH',
+                url: '/users/123',
+                data: { name: 'New Name' },
+                headers: {
+                    Authorization: 'Bearer token123',
+                    'X-Custom-Header': 'custom-value',
+                },
+                timeout: 5000,
+                params: {
+                    fields: 'id,name,email',
+                },
+            });
+        });
+    }
+    getStatistics() {
+        return this.httpClient.getStats();
+    }
+    resetStatistics() {
+        this.httpClient.resetStats();
+    }
+    generateCurlForRequest(url, method = 'GET', data) {
+        const config = {
+            url,
+            method,
+            data,
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'MyApp/1.0',
+            },
+        };
+        return this.httpClient.generateCurlCommand(config);
+    }
+    queryHttpLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            return this.logQueryService.findLogs(options);
+        });
+    }
+    findErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 10) {
+            return this.logQueryService.findErrorLogs({ limit });
+        });
+    }
+    findSlowRequests() {
+        return __awaiter(this, arguments, void 0, function* (minResponseTime = 5000) {
+            return this.logQueryService.findSlowRequests(minResponseTime);
+        });
+    }
+    findRetryLogs() {
+        return __awaiter(this, arguments, void 0, function* (minRetries = 2) {
+            return this.logQueryService.findRetryLogs({ minRetries });
+        });
+    }
+    findLogsByServiceName(serviceName_1) {
+        return __awaiter(this, arguments, void 0, function* (serviceName, limit = 20) {
+            return this.logQueryService.findLogs({ serviceName, limit });
+        });
+    }
+    findLogsByOperationName(operationName_1) {
+        return __awaiter(this, arguments, void 0, function* (operationName, limit = 20) {
+            return this.logQueryService.findLogs({ operationName, limit });
+        });
+    }
+    getHttpStats(startDate, endDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logQueryService.getStats({ startDate, endDate });
+        });
+    }
+    findLogByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logQueryService.findLogByRequestId(requestId);
+        });
+    }
+    cleanupOldLogs() {
+        return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
+            return this.logQueryService.deleteOldLogs(daysToKeep);
+        });
+    }
+};
+exports.BasicHttpExample = BasicHttpExample;
+exports.BasicHttpExample = BasicHttpExample = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [services_1.HttpClientService,
+        services_1.HttpLogQueryService])
+], BasicHttpExample);

package/http-client/examples/index.d.ts

@@ -0,0 +1,3 @@
+export * from './basic-usage.example';
+export * from './advanced-usage.example';
+export * from './multi-api-configuration.example';

package/http-client/examples/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./basic-usage.example"), exports);
+__exportStar(require("./advanced-usage.example"), exports);
+__exportStar(require("./multi-api-configuration.example"), exports);

package/http-client/examples/multi-api-configuration.example.d.ts

@@ -0,0 +1,98 @@
+import { ApiClientInstanceConfig, ApiClientRegistryService } from '../services/api-client-registry.service';
+export declare class GitHubApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get github(): GitHubApiClient;
+    private initializeClients;
+}
+export interface GitHubApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    delete<T = any>(url: string, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class StripeApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get stripe(): StripeApiClient;
+    private initializeClients;
+}
+export interface StripeApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class WeChatApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get wechat(): WeChatApiClient;
+    private initializeClients;
+}
+export interface WeChatApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class CustomApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get customApi(): CustomApiClient;
+    private initializeClients;
+    private getValidToken;
+    private refreshToken;
+    private generateSignature;
+}
+export interface CustomApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    delete<T = any>(url: string, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class ApiManagementService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    createDynamicClient(name: string, config: Partial<ApiClientInstanceConfig>): any;
+    getAllStats(): Record<string, any>;
+    resetAllStats(): void;
+    healthCheck(): Promise<{
+        status: "healthy" | "unhealthy";
+        clients: Record<string, {
+            status: "healthy" | "unhealthy";
+            error?: string;
+        }>;
+    }>;
+    createMultipleClients(configs: ApiClientInstanceConfig[]): void;
+    listClients(): string[];
+}
+export declare class ExampleController {
+    private readonly githubApi;
+    private readonly stripeApi;
+    private readonly wechatApi;
+    private readonly customApi;
+    private readonly apiManagement;
+    constructor(githubApi: GitHubApiService, stripeApi: StripeApiService, wechatApi: WeChatApiService, customApi: CustomApiService, apiManagement: ApiManagementService);
+    getGitHubUser(username: string): Promise<any>;
+    createStripePayment(amount: number, currency: string): Promise<any>;
+    sendWeChatMessage(openid: string, content: string): Promise<any>;
+    getCustomData(id: string): Promise<any>;
+    callDynamicApi(url: string): Promise<any>;
+    getApiHealth(): Promise<{
+        status: "healthy" | "unhealthy";
+        clients: Record<string, {
+            status: "healthy" | "unhealthy";
+            error?: string;
+        }>;
+    }>;
+    getApiStats(): Promise<Record<string, any>>;
+}

package/http-client/examples/multi-api-configuration.example.js

@@ -0,0 +1,353 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExampleController = exports.ApiManagementService = exports.CustomApiService = exports.WeChatApiService = exports.StripeApiService = exports.GitHubApiService = void 0;
+const common_1 = require("@nestjs/common");
+const api_client_registry_service_1 = require("../services/api-client-registry.service");
+let GitHubApiService = class GitHubApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get github() {
+        return this.apiRegistry.getClient('github');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'github',
+            baseURL: 'https://api.github.com',
+            auth: {
+                type: api_client_registry_service_1.AuthType.BEARER_TOKEN,
+                config: {
+                    token: process.env.GITHUB_TOKEN,
+                },
+            },
+            responseTransformer: {
+                dataPath: 'data',
+                success: (response) => response.data,
+                error: (error) => {
+                    var _a, _b;
+                    if ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) {
+                        throw new Error(`GitHub API Error: ${error.response.data.message}`);
+                    }
+                    throw error;
+                },
+            },
+            retry: {
+                enabled: true,
+                retries: 3,
+                retryCondition: (error) => {
+                    var _a, _b;
+                    return (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 403 || ((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 429);
+                },
+            },
+            responseTimeWarningThreshold: 2000,
+            tags: ['github', 'vcs'],
+        });
+    }
+};
+exports.GitHubApiService = GitHubApiService;
+exports.GitHubApiService = GitHubApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], GitHubApiService);
+let StripeApiService = class StripeApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get stripe() {
+        return this.apiRegistry.getClient('stripe');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'stripe',
+            baseURL: 'https://api.stripe.com/v1',
+            auth: {
+                type: api_client_registry_service_1.AuthType.BASIC_AUTH,
+                config: {
+                    username: process.env.STRIPE_SECRET_KEY || '',
+                    password: '',
+                },
+            },
+            defaultHeaders: {
+                'Stripe-Version': '2023-10-16',
+            },
+            responseTransformer: {
+                dataPath: 'data',
+                error: (error) => {
+                    var _a, _b, _c;
+                    if ((_c = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) {
+                        throw new Error(`Stripe API Error: ${error.response.data.error.message}`);
+                    }
+                    throw error;
+                },
+            },
+            responseTimeWarningThreshold: 3000,
+            tags: ['stripe', 'payment'],
+        });
+    }
+};
+exports.StripeApiService = StripeApiService;
+exports.StripeApiService = StripeApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], StripeApiService);
+let WeChatApiService = class WeChatApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get wechat() {
+        return this.apiRegistry.getClient('wechat');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'wechat',
+            baseURL: 'https://api.weixin.qq.com',
+            auth: {
+                type: api_client_registry_service_1.AuthType.NONE,
+            },
+            responseTransformer: {
+                success: (response) => {
+                    if (response.data.errcode !== 0) {
+                        throw new Error(`WeChat API Error (${response.data.errcode}): ${response.data.errmsg}`);
+                    }
+                    return response.data.data;
+                },
+            },
+            tags: ['wechat', 'social'],
+            environments: {
+                development: {
+                    baseURL: 'https://api.tunnel.com/wechat',
+                },
+            },
+        });
+    }
+};
+exports.WeChatApiService = WeChatApiService;
+exports.WeChatApiService = WeChatApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], WeChatApiService);
+let CustomApiService = class CustomApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get customApi() {
+        return this.apiRegistry.getClient('custom-api');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'custom-api',
+            baseURL: process.env.CUSTOM_API_URL,
+            auth: {
+                type: api_client_registry_service_1.AuthType.CUSTOM,
+                config: {
+                    authenticator(config) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            const token = yield this.getValidToken();
+                            config.headers = Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}`, 'X-Timestamp': Date.now().toString(), 'X-Signature': this.generateSignature(config) });
+                            return config;
+                        });
+                    },
+                    refresher(config, error) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            var _a;
+                            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                                const newToken = yield this.refreshToken();
+                                config.headers['Authorization'] = `Bearer ${newToken}`;
+                                return config;
+                            }
+                            throw error;
+                        });
+                    },
+                },
+            },
+            responseTransformer: {
+                success: (response) => {
+                    const result = response.data;
+                    if (result.success === false) {
+                        throw new Error(result.message || 'API request failed');
+                    }
+                    return {
+                        data: result.data || result,
+                        code: result.code || 0,
+                        message: result.message || 'Success',
+                        pagination: result.pagination,
+                        requestId: result.requestId,
+                    };
+                },
+                error: (error) => {
+                    var _a;
+                    if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                        const errorData = error.response.data;
+                        const customError = new Error(errorData.message || 'API request failed');
+                        customError.code = errorData.code;
+                        customError.details = errorData.details;
+                        throw customError;
+                    }
+                    throw error;
+                },
+            },
+            defaultHeaders: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            retry: {
+                enabled: true,
+                retries: 2,
+                retryCondition: (error) => {
+                    if (!error.response)
+                        return true;
+                    return error.response.status >= 500;
+                },
+            },
+            tags: ['custom', 'business'],
+        });
+    }
+    getValidToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'mock-jwt-token';
+        });
+    }
+    refreshToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'refreshed-jwt-token';
+        });
+    }
+    generateSignature(config) {
+        return 'mock-signature';
+    }
+};
+exports.CustomApiService = CustomApiService;
+exports.CustomApiService = CustomApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], CustomApiService);
+let ApiManagementService = class ApiManagementService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+    }
+    createDynamicClient(name, config) {
+        return this.apiRegistry.createClient(Object.assign({ name, baseURL: config.baseURL || '' }, config));
+    }
+    getAllStats() {
+        return this.apiRegistry.getAllStats();
+    }
+    resetAllStats() {
+        this.apiRegistry.resetAllStats();
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiRegistry.healthCheck();
+        });
+    }
+    createMultipleClients(configs) {
+        this.apiRegistry.createClients(configs);
+    }
+    listClients() {
+        return this.apiRegistry.listClients();
+    }
+};
+exports.ApiManagementService = ApiManagementService;
+exports.ApiManagementService = ApiManagementService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], ApiManagementService);
+let ExampleController = class ExampleController {
+    constructor(githubApi, stripeApi, wechatApi, customApi, apiManagement) {
+        this.githubApi = githubApi;
+        this.stripeApi = stripeApi;
+        this.wechatApi = wechatApi;
+        this.customApi = customApi;
+        this.apiManagement = apiManagement;
+    }
+    getGitHubUser(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const github = this.githubApi.github;
+            return github.get(`/users/${username}`);
+        });
+    }
+    createStripePayment(amount, currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stripe = this.stripeApi.stripe;
+            return stripe.post('/charges', {
+                amount,
+                currency,
+                source: 'tok_visa',
+            });
+        });
+    }
+    sendWeChatMessage(openid, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wechat = this.wechatApi.wechat;
+            return wechat.post('/cgi-bin/message/custom/send', {
+                touser: openid,
+                msgtype: 'text',
+                text: {
+                    content,
+                },
+            });
+        });
+    }
+    getCustomData(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const custom = this.customApi.customApi;
+            return custom.get(`/data/${id}`);
+        });
+    }
+    callDynamicApi(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.apiManagement.createDynamicClient('dynamic', {
+                baseURL: url,
+                auth: {
+                    type: api_client_registry_service_1.AuthType.API_KEY,
+                    config: {
+                        key: process.env.DYNAMIC_API_KEY,
+                        location: 'header',
+                        name: 'X-API-Key',
+                    },
+                },
+            });
+            return client.get('/');
+        });
+    }
+    getApiHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiManagement.healthCheck();
+        });
+    }
+    getApiStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiManagement.getAllStats();
+        });
+    }
+};
+exports.ExampleController = ExampleController;
+exports.ExampleController = ExampleController = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [GitHubApiService,
+        StripeApiService,
+        WeChatApiService,
+        CustomApiService,
+        ApiManagementService])
+], ExampleController);