Merge branch 'main' into cezudas/OPS-3888

Author: cezudas

THIRD_PARTY_LICENSES.txt

@@ -185,7 +185,7 @@
     "dotenv": "16.4.5",
     "embla-carousel-react": "8.1.8",
     "fast-deep-equal": "3.1.3",
-    "fastify": "5.4.0",
+    "fastify": "5.8.2",
     "fastify-favicon": "5.0.0",
     "fastify-plugin": "5.0.1",
     "fastify-raw-body": "5.0.0",

package-lock.json

@@ -3,6 +3,8 @@ import { Property, createAction } from '@openops/blocks-framework';
 import {
   amazonAuth,
   getAttributeValues,
+  getAwsAccountsSingleSelectDropdown,
+  getCredentialsForAccount,
   getCredentialsFromAuth,
   getPriceListWithCache,
   getServices,
@@ -17,12 +19,13 @@ export const getPriceAction = createAction({
   displayName: 'Get Price from Price Catalog',
   isWriteAction: false,
   props: {
+    account: getAwsAccountsSingleSelectDropdown().accounts,
     service: Property.Dropdown({
       displayName: 'Service Code',
       description: 'Service code for which to fetch the price',
-      refreshers: ['auth'],
+      refreshers: ['auth', 'account', 'account.accounts'],
       required: true,
-      options: async ({ auth }: any) => {
+      options: async ({ auth, account }: any) => {
         if (!auth) {
           return {
             disabled: true,
@@ -31,8 +34,11 @@ export const getPriceAction = createAction({
           };
         }
 
-        const credentials = await getCredentialsFromAuth(auth);
         try {
+          const credentials = await getCredentialsForAccount(
+            auth,
+            account?.['accounts'],
+          );
           const services = await getServices(credentials, PRICING_REGION);
 
           if (!services.length) {
@@ -66,8 +72,8 @@ export const getPriceAction = createAction({
       displayName: '',
       description: '',
       required: true,
-      refreshers: ['auth', 'service'],
-      props: async ({ auth, service }, { input }) => {
+      refreshers: ['auth', 'account', 'account.accounts', 'service'],
+      props: async ({ auth, account, service }, { input }) => {
         if (!auth || !service) {
           return {};
         }
@@ -101,7 +107,10 @@ export const getPriceAction = createAction({
                   };
                 }
 
-                const credentials = await getCredentialsFromAuth(auth);
+                const credentials = await getCredentialsForAccount(
+                  auth,
+                  account?.['accounts'],
+                );
                 try {
                   const attributeValues: AttributeValue[] =
                     await getAttributeValues(
@@ -139,17 +148,20 @@ export const getPriceAction = createAction({
   },
   async run(context) {
     try {
-      const { service, queryFilters } = context.propsValue;
+      const { account, service, queryFilters } = context.propsValue;
       const filters = queryFilters['queryFilters'].map((filter: any) => {
         return {
           Field: filter.attributeName,
           Type: FilterType.TERM_MATCH,
           Value: filter.attributeValue,
         };
       });
+      const credentials = account?.['accounts']
+        ? await getCredentialsForAccount(context.auth, account['accounts'])
+        : await getCredentialsFromAuth(context.auth);
 
       const priceList = getPriceListWithCache(
-        context.auth,
+        credentials,
         service.ServiceCode!,
         filters,
         PRICING_REGION,

package.json

@@ -1,6 +1,7 @@
 const openopsCommonMock = {
   ...jest.requireActual('@openops/common'),
   getCredentialsFromAuth: jest.fn(),
+  getCredentialsForAccount: jest.fn(),
   getAttributeValues: jest.fn(),
   getServices: jest.fn(),
   getPriceListWithCache: jest.fn(),
@@ -18,6 +19,9 @@ describe('getPriceAction', () => {
     openopsCommonMock.getCredentialsFromAuth.mockResolvedValue({
       someCreds: 'some value',
     });
+    openopsCommonMock.getCredentialsForAccount.mockResolvedValue({
+      someCreds: 'some value',
+    });
   });
 
   const auth = {
@@ -34,12 +38,16 @@ describe('getPriceAction', () => {
     },
     auth: auth,
     propsValue: {
-      accountId: 'some account id',
+      account: { accounts: 'some account id' },
     },
   };
 
   test('should create action with correct properties', () => {
     expect(getPriceAction.props).toMatchObject({
+      account: {
+        type: 'DYNAMIC',
+        required: true,
+      },
       service: {
         type: 'DROPDOWN',
         required: true,
@@ -80,22 +88,40 @@ describe('getPriceAction', () => {
 
       expect(openopsCommonMock.getPriceListWithCache).toHaveBeenCalledTimes(1);
       expect(openopsCommonMock.getPriceListWithCache).toHaveBeenCalledWith(
-        auth,
+        { someCreds: 'some value' },
         'some service',
         expectedFilters,
         'us-east-1',
       );
+      expect(openopsCommonMock.getCredentialsForAccount).toHaveBeenCalledWith(
+        auth,
+        'some account id',
+      );
     },
   );
 
+  test('should fallback to getCredentialsFromAuth when account is missing in run', async () => {
+    openopsCommonMock.getPriceListWithCache.mockResolvedValue('mockResult');
+    context.propsValue = {
+      service: { ServiceCode: 'some service' },
+      queryFilters: { queryFilters: [] },
+    };
+
+    const result = (await getPriceAction.run(context)) as any;
+
+    expect(result).toEqual('mockResult');
+    expect(openopsCommonMock.getCredentialsFromAuth).toHaveBeenCalledWith(auth);
+    expect(openopsCommonMock.getCredentialsForAccount).not.toHaveBeenCalled();
+  });
+
   test('should return the list of services in property service', async () => {
     openopsCommonMock.getServices.mockResolvedValue([
       { ServiceCode: 'service1' },
       { ServiceCode: 'service2' },
     ]);
 
     const result = await getPriceAction.props['service'].options(
-      { auth },
+      { auth, account: { accounts: 'some account id' } },
       context,
     );
 
@@ -118,6 +144,7 @@ describe('getPriceAction', () => {
       ServiceCode: 'some service',
       AttributeNames: ['some attibute'],
     };
+    context.propsValue.account = { accounts: 'some account id' };
     context.propsValue.auth = auth;
     context.input = { attributeName: 'some attibute' };
 

packages/blocks/aws/src/lib/actions/get-price-action.ts

@@ -14,6 +14,7 @@ import {
   TestRunLimitSettings,
   TriggerHookType,
 } from '@openops/shared';
+import { parseJsonResponse } from '../../helper/response-helper';
 import {
   createPropsResolver,
   PropsResolver,
@@ -232,7 +233,7 @@ export class EngineConstants {
       },
     });
 
-    return (await response.json()) as Project;
+    return parseJsonResponse<Project>(response);
   }
 }
 

packages/blocks/aws/test/get-price-action.test.ts

@@ -100,6 +100,17 @@ export class FetchError extends ExecutionError {
   }
 }
 
+export class InfrastructureError extends ExecutionError {
+  constructor(message: string, cause?: unknown) {
+    super(
+      'InfrastructureError',
+      formatMessage(message),
+      ExecutionErrorType.ENGINE,
+      cause,
+    );
+  }
+}
+
 export class ExecutionLimitReachedError extends ExecutionError {
   formated: boolean;
 

packages/engine/src/lib/handler/context/engine-constants.ts

@@ -0,0 +1,31 @@
+import { logger } from '@openops/server-shared';
+import { InfrastructureError } from './execution-errors';
+
+export const parseJsonResponse = async <T>(response: Response): Promise<T> => {
+  const contentType = response.headers.get('content-type');
+  const text = await response.text();
+
+  if (contentType && !contentType.includes('application/json')) {
+    logger.warn('Expected JSON response but received non-JSON content type', {
+      status: response.status,
+      contentType,
+      body: text,
+    });
+    throw new InfrastructureError(
+      `Expected JSON response, but received status ${response.status} and ${contentType}.`,
+    );
+  }
+
+  try {
+    return JSON.parse(text) as T;
+  } catch (e) {
+    logger.warn('Failed to parse JSON response', {
+      status: response.status,
+      body: text,
+    });
+    throw new InfrastructureError(
+      `Failed to parse JSON response with status ${response.status}.`,
+      e,
+    );
+  }
+};

packages/engine/src/lib/helper/execution-errors.ts

@@ -34,7 +34,10 @@ import {
 import { testExecutionContext } from './handler/context/test-execution-context';
 import { flowExecutor } from './handler/flow-executor';
 import { blockHelper } from './helper/block-helper';
-import { ExecutionLimitReachedError } from './helper/execution-errors';
+import {
+  ExecutionLimitReachedError,
+  InfrastructureError,
+} from './helper/execution-errors';
 import { triggerHelper } from './helper/trigger-helper';
 import { resolveVariable } from './resolve-variable';
 import { progressService } from './services/progress.service';
@@ -330,6 +333,10 @@ function evaluateError(error: Error): {
     message = error.getMessage();
   }
 
+  if (error instanceof InfrastructureError) {
+    status = FlowRunStatus.INFRASTRUCTURE_ERROR;
+  }
+
   return {
     status,
     message,

packages/engine/src/lib/helper/response-helper.ts

@@ -11,9 +11,9 @@ import {
   ConnectionExpiredError,
   ConnectionLoadingError,
   ConnectionNotFoundError,
-  ExecutionError,
   FetchError,
 } from '../helper/execution-errors';
+import { parseJsonResponse } from '../helper/response-helper';
 
 export const createConnectionService = ({
   projectId,
@@ -40,16 +40,13 @@ export const createConnectionService = ({
             httpStatus: response.status,
           });
         }
-        const connection: AppConnection = await response.json();
+        const connection: AppConnection =
+          await parseJsonResponse<AppConnection>(response);
         if (connection.status === AppConnectionStatus.ERROR) {
           throw new ConnectionExpiredError(connectionName);
         }
         return getConnectionValue(connection);
       } catch (e) {
-        if (e instanceof ExecutionError) {
-          throw e;
-        }
-
         return handleFetchError({
           url,
           cause: e,