@newpeak/barista-cli 0.1.5 → 0.1.7

package/src/core/api/client.ts

@@ -34,8 +34,27 @@ import {
   UomQueryParams,
   UomApiResponse,
 } from '../../types/uom.js';
+import {
+  CreateCurrencyRequest,
+  UpdateCurrencyRequest,
+  CurrencyQueryParams,
+  CurrencyApiResponse,
+  CurrencyDefaultResponse,
+} from '../../types/currency.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { ApiResponse, Material, MaterialApiResponse, MaterialQueryParams, MaterialRequest } from '../../types/material.js';
+import {
+  WarehouseQueryParams,
+  WarehouseApiResponse,
+  CreateWarehouseRequest,
+  UpdateWarehouseRequest,
+} from '../../types/warehouse.js';
+import {
+  LocationQueryParams,
+  LocationApiResponse,
+  CreateLocationRequest,
+  UpdateLocationRequest,
+} from '../../types/location.js';
 
 export interface LoginResponse {
   token: string;
@@ -1364,6 +1383,502 @@ export const apiClient = {
     }
   },
 
+  async listCurrencies(
+    environment: Environment,
+    tenant: string,
+    params: CurrencyQueryParams
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.currencyCode) queryString.append('currencyCode', params.currencyCode);
+      if (params.currencyName) queryString.append('currencyName', params.currencyName);
+      const url = `/api/enterprise/sales/currency/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<CurrencyApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getCurrency(
+    environment: Environment,
+    tenant: string,
+    currencyId: string
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<CurrencyApiResponse>(
+        `/api/enterprise/sales/currency/detail?currencyId=${currencyId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getAvailableCurrencies(
+    environment: Environment,
+    tenant: string
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<CurrencyApiResponse>('/api/enterprise/master/currency/available/list');
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getCurrencyDefault(
+    environment: Environment,
+    tenant: string,
+    currencyCode: string
+  ): Promise<CurrencyDefaultResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<CurrencyDefaultResponse>(
+        `/api/enterprise/master/currency/currency/default?currencyCode=${currencyCode}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error) as CurrencyDefaultResponse;
+    }
+  },
+
+  async createCurrency(
+    environment: Environment,
+    tenant: string,
+    data: CreateCurrencyRequest
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<CurrencyApiResponse>('/api/enterprise/sales/currency/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async updateCurrency(
+    environment: Environment,
+    tenant: string,
+    data: UpdateCurrencyRequest
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<CurrencyApiResponse>('/api/enterprise/sales/currency/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async deleteCurrency(
+    environment: Environment,
+    tenant: string,
+    currencyId: string
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/delete',
+        { currencyId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async enableCurrencies(
+    environment: Environment,
+    tenant: string,
+    currencyIds: string[]
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/batchActive',
+        { currencyIdList: currencyIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async disableCurrencies(
+    environment: Environment,
+    tenant: string,
+    currencyIds: string[]
+  ): Promise<CurrencyApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/batchDeActive',
+        { currencyIdList: currencyIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async listWarehouses(
+    environment: Environment,
+    tenant: string,
+    params: WarehouseQueryParams
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/page',
+        { params }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async getWarehouse(
+    environment: Environment,
+    tenant: string,
+    warehouseId: string
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<WarehouseApiResponse>(
+        `/api/enterprise/purchases/warehouse/detail?warehouseId=${warehouseId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async createWarehouse(
+    environment: Environment,
+    tenant: string,
+    data: CreateWarehouseRequest
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/add',
+        data
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async updateWarehouse(
+    environment: Environment,
+    tenant: string,
+    data: UpdateWarehouseRequest
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/edit',
+        data
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async deleteWarehouse(
+    environment: Environment,
+    tenant: string,
+    warehouseId: string
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/delete',
+        { warehouseId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async batchEnableWarehouses(
+    environment: Environment,
+    tenant: string,
+    warehouseIds: string[]
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/batchActive',
+        { warehouseIdList: warehouseIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async batchDisableWarehouses(
+    environment: Environment,
+    tenant: string,
+    warehouseIds: string[]
+  ): Promise<WarehouseApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<WarehouseApiResponse>(
+        '/api/enterprise/purchases/warehouse/batchDeActive',
+        { warehouseIdList: warehouseIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorWarehouse(error);
+    }
+  },
+
+  async listLocations(
+    environment: Environment,
+    tenant: string,
+    params: LocationQueryParams
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/page',
+        { params }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async getLocation(
+    environment: Environment,
+    tenant: string,
+    warehouseLocationId: string
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<LocationApiResponse>(
+        `/api/enterprise/purchases/warehouse/location/detail?warehouseLocationId=${warehouseLocationId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async createLocation(
+    environment: Environment,
+    tenant: string,
+    data: CreateLocationRequest
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/add',
+        data
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async updateLocation(
+    environment: Environment,
+    tenant: string,
+    data: UpdateLocationRequest
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/edit',
+        data
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async deleteLocation(
+    environment: Environment,
+    tenant: string,
+    warehouseLocationId: string
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/delete',
+        { warehouseLocationId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async batchEnableLocations(
+    environment: Environment,
+    tenant: string,
+    warehouseLocationIds: string[]
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/batchActive',
+        { warehouseLocationIdList: warehouseLocationIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
+  async batchDisableLocations(
+    environment: Environment,
+    tenant: string,
+    warehouseLocationIds: string[]
+  ): Promise<LocationApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<LocationApiResponse>(
+        '/api/enterprise/purchases/warehouse/location/batchDeActive',
+        { warehouseLocationIdList: warehouseLocationIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorLocation(error);
+    }
+  },
+
 };
 
 function handleApiError(error: unknown): EmployeeApiResponse {
@@ -1559,4 +2074,121 @@ function handleApiErrorUom(error: unknown): UomApiResponse {
       message: error instanceof Error ? error.message : 'Unknown error occurred',
     },
   };
+}
+
+function handleApiErrorWarehouse(error: unknown): WarehouseApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as WarehouseApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}
+
+function handleApiErrorLocation(error: unknown): LocationApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as LocationApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}
+
+function handleApiErrorCurrency(error: unknown): CurrencyApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as CurrencyApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
 }

package/src/index.ts

@@ -15,11 +15,9 @@ async function main(): Promise<void> {
     program
       .name('barista')
       .description('Barista CLI - Bridge between AI agents and Liberica/Arabica')
-      .version('0.1.5')
+      .version('0.1.7')
       .option('-e, --env <environment>', 'Target environment (dev|test|prod-cn|prod-jp)')
       .option('-t, --tenant <tenant>', 'Target tenant (for Liberica)')
-      .option('--dry-run', 'Execute in dry-run mode')
-      .option('--json', 'Output as JSON')
       .option('--debug', 'Enable debug mode');
 
     program.addCommand(createContextCommand());