funifier-mcp 0.1.0

package/dist/core/api-client.js

@@ -0,0 +1,796 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAPIClient = createAPIClient;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("./constants");
+function createAPIClient(config) {
+    if (!config.apiKey || !config.secretKey || !config.serverUrl) {
+        throw new Error("Funifier config is required: apiKey, secretKey, and serverUrl must be provided");
+    }
+    const axiosClient = axios_1.default.create({
+        baseURL: `${config.serverUrl}${constants_1.API.BASE_PATH}`,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${Buffer.from(`${config.apiKey}:${config.secretKey}`).toString("base64")}`,
+            Range: constants_1.API.RANGE_HEADER,
+        },
+    });
+    return {
+        // --- Triggers ---
+        listTriggers: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.TRIGGER);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveTrigger: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.TRIGGER, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to update trigger: " + e);
+            }
+        },
+        deleteTrigger: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.TRIGGER}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete trigger: " + e);
+            }
+        },
+        getTriggerLogs: async (id) => {
+            try {
+                const payload = [
+                    {
+                        $match: { _id: id },
+                    },
+                ];
+                const response = await axiosClient.post(constants_1.Endpoints.TRIGGER_LOG, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        // --- Schedulers ---
+        listSchedulers: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.SCHEDULER_FETCH);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveScheduler: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.SCHEDULER, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteScheduler: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.SCHEDULER}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete scheduler: " + e);
+            }
+        },
+        executeScheduler: async (id) => {
+            try {
+                const response = await axiosClient.get(`${constants_1.Endpoints.SCHEDULER}/execute/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error("Failed to execute scheduler: " + e);
+            }
+        },
+        getSchedulerLogs: async (id) => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.SCHEDULER_LOG, {
+                    params: { orderby: "time", reverse: true, max_results: 10, item: id },
+                });
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        // --- Aggregates ---
+        listAggregates: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.AGGREGATE);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveAggregate: async (payload) => {
+            try {
+                const response = await axiosClient.put(constants_1.Endpoints.AGGREGATE, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteAggregate: async (id) => {
+            try {
+                const response = await axiosClient.delete(constants_1.Endpoints.AGGREGATE_BY_ID(id));
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete aggregate: " + e);
+            }
+        },
+        executeAggregate: async (id, params) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.AGGREGATE_FIND(id), params);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error("Failed to execute aggregate: " + e);
+            }
+        },
+        analyzeAggregate: async (id, params) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.AGGREGATE_ANALYZE(id), params);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error("Failed to analyze aggregate: " + e);
+            }
+        },
+        getAggregateParams: async (id) => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.AGGREGATE_PARAMS(id));
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error("Failed to get aggregate params: " + e);
+            }
+        },
+        // --- Websockets ---
+        listWebsockets: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.WEBSOCKET);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveWebsocket: async (payload, isNew) => {
+            try {
+                const data = { ...payload, isNew };
+                const response = await axiosClient.post(constants_1.Endpoints.WEBSOCKET_UPDATE, data);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteWebsocket: async (id) => {
+            try {
+                await axiosClient.delete(`${constants_1.Endpoints.WEBSOCKET_UPDATE}/${id}`);
+                return { success: true };
+            }
+            catch (e) {
+                throw new Error("Failed to delete websocket: " + e);
+            }
+        },
+        // --- Widgets ---
+        listWidgets: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.WIDGET);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        getWidgetById: async (id) => {
+            try {
+                const response = await axiosClient.get(`${constants_1.Endpoints.WIDGET}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        saveWidget: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.WIDGET, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteWidget: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.WIDGET}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete widget: " + e);
+            }
+        },
+        // --- Custom Pages ---
+        listCustomPages: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.CUSTOM_PAGE);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveCustomPage: async (payload) => {
+            try {
+                const response = await axiosClient.put(constants_1.Endpoints.CUSTOM_PAGE, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteCustomPage: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.CUSTOM_PAGE}?q=_id:'${id}'`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete custom page: " + e);
+            }
+        },
+        // --- Public Endpoints ---
+        listPublicEndpoints: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.PUBLIC_ENDPOINT);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        savePublicEndpoint: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.PUBLIC_ENDPOINT_UPDATE, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deletePublicEndpoint: async (id) => {
+            try {
+                const response = await axiosClient.delete(constants_1.Endpoints.PUBLIC_ENDPOINT_BY_ID(id));
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete public endpoint: " + e);
+            }
+        },
+        executePublicEndpoint: async (apiKey, id, payload, method) => {
+            try {
+                const url = `/pub/${apiKey}/${id}`;
+                const response = method.toUpperCase() === "GET"
+                    ? await axiosClient.get(url)
+                    : await axiosClient.post(url, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                if (e.response?.data) {
+                    return e.response.data;
+                }
+                throw new Error("Failed to execute public endpoint: " + e);
+            }
+        },
+        // --- Challenge Aggregates ---
+        listChallengeAggregates: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.CHALLENGE_AGGREGATE);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveChallengeAggregate: async (payload) => {
+            try {
+                const response = await axiosClient.put(constants_1.Endpoints.CHALLENGE_AGGREGATE, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteChallengeAggregate: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.CHALLENGE_AGGREGATE}?q=_id:'${id}'`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete challenge aggregate: " + e);
+            }
+        },
+        // --- Auth Modules ---
+        listAuthModules: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.AUTH_MODULE);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveAuthModule: async (payload, isNew) => {
+            try {
+                const data = { ...payload, isNew };
+                const response = await axiosClient.post(constants_1.Endpoints.AUTH_MODULE_UPDATE, data);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteAuthModule: async (id) => {
+            try {
+                await axiosClient.delete(`${constants_1.Endpoints.AUTH_MODULE_UPDATE}/${id}`);
+                return { success: true };
+            }
+            catch (e) {
+                throw new Error("Failed to delete auth module: " + e);
+            }
+        },
+        // --- AI Knowledge ---
+        listAiKnowledge: async () => {
+            try {
+                const response = await axiosClient.post(`${constants_1.Endpoints.AI_KNOWLEDGE}/aggregate`, []);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveAiKnowledge: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.AI_KNOWLEDGE, payload);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return undefined;
+            }
+        },
+        deleteAiKnowledge: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.AI_KNOWLEDGE}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete AI knowledge: " + e);
+            }
+        },
+        // --- Studio Page Folders ---
+        getStudioPageFolders: async () => {
+            try {
+                const response = await axiosClient.get(`${constants_1.Endpoints.CUSTOM_PAGE}_folder`);
+                const data = response.data;
+                if (Array.isArray(data))
+                    return data;
+                if (data && typeof data === "object")
+                    return [data];
+                return [];
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        // --- Utility ---
+        evaluateCron: async (expression) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.CRON_VALIDATE, {
+                    expression,
+                    language: "en",
+                });
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error("Failed to evaluate cron expression: " + e);
+            }
+        },
+        getCollections: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.COLLECTIONS);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        // --- Database (generic collection access) ---
+        queryCollection: async (collection, query = {}, options = {}) => {
+            try {
+                const params = {};
+                if (Object.keys(query).length > 0) {
+                    params.q = JSON.stringify(query);
+                }
+                if (options.sort) {
+                    params.sort = JSON.stringify(options.sort);
+                }
+                if (options.limit) {
+                    params.limit = String(options.limit);
+                }
+                if (options.skip) {
+                    params.skip = String(options.skip);
+                }
+                const response = await axiosClient.get(`/database/${collection}`, { params });
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        aggregateCollection: async (collection, pipeline) => {
+            try {
+                const response = await axiosClient.post(`/database/${collection}/aggregate`, pipeline);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to aggregate on ${collection}: ${e}`);
+            }
+        },
+        insertDocument: async (collection, data) => {
+            try {
+                const response = await axiosClient.post(`/database/${collection}`, data);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to insert document into ${collection}: ${e}`);
+            }
+        },
+        updateDocument: async (collection, data) => {
+            try {
+                const response = await axiosClient.put(`/database/${collection}`, data);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to update document in ${collection}: ${e}`);
+            }
+        },
+        deleteDocument: async (collection, query) => {
+            try {
+                const response = await axiosClient.delete(`/database/${collection}?q=${query}`);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to delete document from ${collection}: ${e}`);
+            }
+        },
+        bulkInsert: async (collection, data) => {
+            try {
+                const response = await axiosClient.post(`/database/${collection}/bulk`, data);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to bulk insert into ${collection}: ${e}`);
+            }
+        },
+        // --- Actions ---
+        listActions: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.ACTION);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveAction: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.ACTION, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save action: " + e);
+            }
+        },
+        deleteAction: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.ACTION}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete action: " + e);
+            }
+        },
+        // --- Challenges ---
+        listChallenges: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.CHALLENGE);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveChallenge: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.CHALLENGE, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save challenge: " + e);
+            }
+        },
+        deleteChallenge: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.CHALLENGE}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete challenge: " + e);
+            }
+        },
+        // --- Points ---
+        listPoints: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.POINT);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        savePoint: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.POINT, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save point: " + e);
+            }
+        },
+        deletePoint: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.POINT}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete point: " + e);
+            }
+        },
+        // --- Levels ---
+        listLevels: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.LEVEL);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveLevel: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.LEVEL, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save level: " + e);
+            }
+        },
+        deleteLevel: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.LEVEL}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete level: " + e);
+            }
+        },
+        saveLevelConfig: async (payload) => {
+            try {
+                const response = await axiosClient.put(constants_1.Endpoints.LEVEL_CONFIG, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save level config: " + e);
+            }
+        },
+        // --- Leaderboards ---
+        listLeaderboards: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.LEADERBOARD);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveLeaderboard: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.LEADERBOARD, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save leaderboard: " + e);
+            }
+        },
+        deleteLeaderboard: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.LEADERBOARD}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete leaderboard: " + e);
+            }
+        },
+        getLeaderboardResults: async (id) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.LEADERBOARD_LEADERS(id), []);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        // --- Quizzes ---
+        listQuizzes: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.QUIZ_LIST);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveQuiz: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.QUIZ, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save quiz: " + e);
+            }
+        },
+        deleteQuiz: async (id) => {
+            try {
+                const response = await axiosClient.delete(`${constants_1.Endpoints.QUIZ}/${id}`);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to delete quiz: " + e);
+            }
+        },
+        listQuizQuestions: async (quizId) => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.QUIZ_QUESTION_BY_QUIZ(quizId));
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveQuestion: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.QUIZ_QUESTION, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save question: " + e);
+            }
+        },
+        // --- Virtual Goods ---
+        listVirtualGoodCatalogs: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.VIRTUAL_GOOD_CATALOG);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveVirtualGoodCatalog: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.VIRTUAL_GOOD_CATALOG, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save virtual good catalog: " + e);
+            }
+        },
+        listVirtualGoodItems: async () => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.VIRTUAL_GOOD_ITEM);
+                return response.data;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        },
+        saveVirtualGoodItem: async (payload) => {
+            try {
+                const response = await axiosClient.post(constants_1.Endpoints.VIRTUAL_GOOD_ITEM, payload);
+                return response.data;
+            }
+            catch (e) {
+                throw new Error("Failed to save virtual good item: " + e);
+            }
+        },
+        getGamification: async (apiKey) => {
+            try {
+                const response = await axiosClient.get(constants_1.Endpoints.GAMIFICATION(apiKey));
+                return response.data;
+            }
+            catch (e) {
+                if (e.response?.data) {
+                    return e.response.data;
+                }
+                console.error(e);
+                throw e;
+            }
+        },
+    };
+}
+//# sourceMappingURL=api-client.js.map