@newpeak/barista-cli 0.1.209 → 0.1.225

package/dist/core/api/client.js

@@ -32,7 +32,20 @@ export class APIClient {
                 account: username,
                 password,
             });
-            return response.data;
+            const data = response.data;
+            const rawData = data;
+            if (data && rawData.success === false) {
+                const errCode = rawData.error?.code || rawData.code || 'UNKNOWN_ERROR';
+                const errMsg = rawData.error?.message || rawData.message || 'Unknown error';
+                return {
+                    success: false,
+                    error: {
+                        code: errCode,
+                        message: errMsg,
+                    },
+                };
+            }
+            return data;
         }
         catch (error) {
             if (axios.isAxiosError(error)) {
@@ -9649,6 +9662,194 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
+    // ============================================
+    // Caturra Metadata Query API
+    // ============================================
+    async getCaturraTables(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            if (params.tablePattern)
+                searchParams.append('tablePattern', params.tablePattern);
+            if (params.clientId)
+                searchParams.append('clientId', params.clientId);
+            const url = `/api/enterprise/caturra/metadata/tables?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async getCaturraColumns(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            searchParams.append('tableName', params.tableName);
+            if (params.clientId)
+                searchParams.append('clientId', params.clientId);
+            const url = `/api/enterprise/caturra/metadata/columns?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async searchCaturraTables(environment, tenant, keyword) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            searchParams.append('keyword', keyword);
+            const url = `/api/enterprise/caturra/metadata/search?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async getCaturraDatabaseInfo(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            if (params.clientId)
+                searchParams.append('clientId', params.clientId);
+            const url = `/api/enterprise/caturra/metadata/database-info?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async executeCaturraQuery(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = '/api/enterprise/caturra/metadata/query';
+            const response = await client.getClient().post(url, {
+                clientId: params.clientId,
+                sql: params.sql,
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async refreshCaturraMetadata(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = '/api/enterprise/caturra/metadata/refresh';
+            const response = await client.getClient().post(url, {
+                clientId: params.clientId,
+                forceRefresh: params.forceRefresh ?? true,
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async listCaturraClients(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            if (params.pageNo)
+                searchParams.append('pageNo', String(params.pageNo));
+            if (params.pageSize)
+                searchParams.append('pageSize', String(params.pageSize));
+            if (params.status)
+                searchParams.append('status', params.status);
+            if (params.searchText)
+                searchParams.append('searchText', params.searchText);
+            const url = `/api/enterprise/caturra/client/page?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async registerCaturraClient(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = '/api/enterprise/caturra/client/register';
+            const response = await client.getClient().post(url, data);
+            return { success: true, data: response.data?.data ?? response.data };
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async approveCaturraClient(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = '/api/enterprise/caturra/client/approve';
+            const response = await client.getClient().post(url, {
+                clientId: params.clientId,
+                remark: params.approverRemark,
+            });
+            return { success: true, data: response.data?.data ?? response.data };
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
+    async revokeCaturraClient(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = '/api/enterprise/caturra/client/revoke';
+            const response = await client.getClient().post(url, {
+                clientId: params.clientId,
+                reason: params.reason,
+            });
+            return { success: true, data: response.data?.data ?? response.data };
+        }
+        catch (error) {
+            return handleApiErrorCaturra(error);
+        }
+    },
 };
 function handleApiErrorStockReservation(error) {
     return extractApiError(error);
@@ -9716,25 +9917,33 @@ export function extractApiError(error, context) {
                             },
                         };
                     }
+                    const exceptionTip = responseData.exceptionTip;
+                    const enhancedMessage = exceptionTip
+                        ? `${message || 'API error occurred'}\n  Backend: ${exceptionTip}`
+                        : (message || 'API error occurred');
                     return {
                         success: false,
                         error: {
                             code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
+                            message: enhancedMessage,
                         },
                     };
                 }
             }
             // Fallback: passthrough for already-normalized responses
+            const fallbackMessage = responseData.error?.message ||
+                responseData.message ||
+                'API error occurred';
+            const exceptionTip = responseData.exceptionTip;
             return {
                 success: false,
                 error: {
                     code: responseData.error?.code ||
                         responseData.code ||
                         'API_ERROR',
-                    message: responseData.error?.message ||
-                        responseData.message ||
-                        'API error occurred',
+                    message: exceptionTip
+                        ? `${fallbackMessage}\n  Backend: ${exceptionTip}`
+                        : fallbackMessage,
                 },
             };
         }
@@ -9904,4 +10113,7 @@ function handleApiErrorSupplierPrice(error) {
 function handleApiErrorHrs(error) {
     return extractApiError(error);
 }
+function handleApiErrorCaturra(error) {
+    return extractApiError(error);
+}
 //# sourceMappingURL=client.js.map